Week+1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (UM)",
      "language": "python",
      "name": "logging"
    },
    "language_info": {
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python"
    },
    "colab": {
      "name": "Week+1.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/madhukesh048/Data-Science/blob/master/Week%2B1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ElZmv9TWXKVl",
        "colab_type": "text"
      },
      "source": [
        "# The Python Programming Language: Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RtLm-Qx1XKVn",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`add_numbers` is a function that takes two numbers and adds them together."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4saMJKLsXKVp",
        "colab_type": "code",
        "colab": {},
        "outputId": "110ae5c8-e1f1-4277-eb6f-f546f2fc75b9"
      },
      "source": [
        "def add_numbers(x, y):\n",
        "    return x + y\n",
        "\n",
        "add_numbers(1, 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fx_iCNBoXKVx",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`add_numbers` updated to take an optional 3rd parameter. Using `print` allows printing of multiple expressions within a single cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DwMlb6nuXKVy",
        "colab_type": "code",
        "colab": {},
        "outputId": "cfcd8b4e-8627-4c25-c182-4c61cd130a69"
      },
      "source": [
        "def add_numbers(x,y,z=None):\n",
        "    if (z==None):\n",
        "        return x+y\n",
        "    else:\n",
        "        return x+y+z\n",
        "\n",
        "print(add_numbers(1, 2))\n",
        "print(add_numbers(1, 2, 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2KlODaVGXKV4",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`add_numbers` updated to take an optional flag parameter."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m8t4cvBqXKV5",
        "colab_type": "code",
        "colab": {},
        "outputId": "2d556ea5-7bd3-470c-95b9-ecf6d9cb9a0e"
      },
      "source": [
        "def add_numbers(x, y, z=None, flag=False):\n",
        "    if (flag):\n",
        "        print('Flag is true!')\n",
        "    if (z==None):\n",
        "        return x + y\n",
        "    else:\n",
        "        return x + y + z\n",
        "    \n",
        "print(add_numbers(1, 2, flag=True))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Flag is true!\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mbxWz95zXKV-",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Assign function `add_numbers` to variable `a`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iA1nwJHmXKV_",
        "colab_type": "code",
        "colab": {},
        "outputId": "df14216d-e81a-4ce4-c6f9-5576aa91e6ef"
      },
      "source": [
        "def add_numbers(x,y):\n",
        "    return x+y\n",
        "\n",
        "a = add_numbers\n",
        "a(1,2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IKdEpeqOXKWE",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# The Python Programming Language: Types and Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2_ozddQoXKWF",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `type` to return the object's type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZHLBJZIGXKWG",
        "colab_type": "code",
        "colab": {},
        "outputId": "b4e4ca42-296e-410e-edfd-c19fe779d13c"
      },
      "source": [
        "type('This is a string')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2nXRSTpqXKWK",
        "colab_type": "code",
        "colab": {},
        "outputId": "17020e3b-a0e0-4785-df46-bf5c938d1804"
      },
      "source": [
        "type(None)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "NoneType"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rH_b1S-YXKWQ",
        "colab_type": "code",
        "colab": {},
        "outputId": "b7fa76d0-7103-44cb-998d-b389d9f074c6"
      },
      "source": [
        "type(1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rsEVDcaOXKWU",
        "colab_type": "code",
        "colab": {},
        "outputId": "fa639d73-940b-4e19-deb5-0133d1670115"
      },
      "source": [
        "type(1.0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tlVO-figXKWZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "494a5dc2-ead1-48dc-ad41-646eada774bd"
      },
      "source": [
        "type(add_numbers)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "function"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2YxVyXr7XKWc",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Tuples are an immutable data structure (cannot be altered)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sKPkGh7JXKWk",
        "colab_type": "code",
        "colab": {},
        "outputId": "27122c23-0290-43dc-aa7c-5fc4d4f65185"
      },
      "source": [
        "x = (1, 'a', 2, 'b')\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "79N9c-M_XKWp",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Lists are a mutable data structure."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h0hS5opCXKWp",
        "colab_type": "code",
        "colab": {},
        "outputId": "9f9ffa80-7ff2-455c-a64e-b111477985e2"
      },
      "source": [
        "x = [1, 'a', 2, 'b']\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dUz3qXi6XKWu",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `append` to append an object to a list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GkAy2p72XKWv",
        "colab_type": "code",
        "colab": {},
        "outputId": "f36903ca-6c1a-4961-f365-6ec8c535dae7"
      },
      "source": [
        "x.append(3.3)\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 'a', 2, 'b', 3.3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YxqTvj47XKWy",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "This is an example of how to loop through each item in the list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K3amdCU8XKWz",
        "colab_type": "code",
        "colab": {},
        "outputId": "19d09f07-e13c-40a3-cedc-562b7655d9fb"
      },
      "source": [
        "for item in x:\n",
        "    print(item,end=\"\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1a2b3.3"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c0cBUa5kXKW4",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Or using the indexing operator:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DndLNKyDXKW5",
        "colab_type": "code",
        "colab": {},
        "outputId": "51f4a398-0691-4b26-d4a9-513913f24f8f"
      },
      "source": [
        "i=0\n",
        "while( i != len(x) ):\n",
        "    print(x[i])\n",
        "    i = i + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "a\n",
            "2\n",
            "b\n",
            "3.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i8iiZW-wXKW9",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `+` to concatenate lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "urnGKQiLXKW-",
        "colab_type": "code",
        "colab": {},
        "outputId": "487e3995-2f73-4d1e-e78c-fb884c15259a"
      },
      "source": [
        "[1,2] + [3,4]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jWg_HfEeXKXE",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `*` to repeat lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jj3e09icXKXH",
        "colab_type": "code",
        "colab": {},
        "outputId": "aa31ba94-3e24-49d2-a9eb-1d6512a327d8"
      },
      "source": [
        "[1]*3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 1, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WzU358IeXKXK",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use the `in` operator to check if something is inside a list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5QJzztkXKXL",
        "colab_type": "code",
        "colab": {},
        "outputId": "0999af39-2e6a-422a-bf54-9ab997e369c2"
      },
      "source": [
        "1 in [1, 2, 3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kLxBp9QcXKXO",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Now let's look at strings. Use bracket notation to slice a string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1bM_-Z4XKXP",
        "colab_type": "code",
        "colab": {},
        "outputId": "1b3edd8b-ea13-4313-d9aa-0452d20d5ac4"
      },
      "source": [
        "x = 'This is a string'\n",
        "print(x[0]) #first character\n",
        "print(x[0:1]) #first character, but we have explicitly set the end character\n",
        "print(x[0:2]) #first two characters\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T\n",
            "T\n",
            "Th\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gTAuXDn7XKXT",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "This will return the last element of the string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0abfiMDvXKXT",
        "colab_type": "code",
        "colab": {},
        "outputId": "fdc05e54-db58-4ad2-a837-19da5df243e5"
      },
      "source": [
        "x[-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'g'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vHUXbIqUXKXY",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "This will return the slice starting from the 4th element from the end and stopping before the 2nd element from the end."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nGUmUS9iXKXY",
        "colab_type": "code",
        "colab": {},
        "outputId": "5aeee3a0-f39f-42cc-ce00-844aa4461689"
      },
      "source": [
        "x[-4:-2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'ri'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuKLCrTJXKXb",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "This is a slice from the beginning of the string and stopping before the 3rd element."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UdifXJ5VXKXb",
        "colab_type": "code",
        "colab": {},
        "outputId": "1175edbd-bd90-43f9-f7c0-2bca6be5081e"
      },
      "source": [
        "x[:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Thi'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tf3pSiElXKXg",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "And this is a slice starting from the 4th element of the string and going all the way to the end."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qK-1_wdHXKXh",
        "colab_type": "code",
        "colab": {},
        "outputId": "8d42af70-f690-40fc-ae5b-a2088e44713f"
      },
      "source": [
        "x[3:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'s is a string'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tr2kuXhEXKXl",
        "colab_type": "code",
        "colab": {},
        "outputId": "366ac47d-2de8-4a2c-8e33-2b769703f5c7"
      },
      "source": [
        "firstname = 'Christopher'\n",
        "lastname = 'Brooks'\n",
        "\n",
        "print(firstname + ' ' + lastname)\n",
        "print(firstname*3)\n",
        "print('Chris' in firstname)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Christopher Brooks\n",
            "ChristopherChristopherChristopher\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O9JIOblSXKXp",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`split` returns a list of all the words in a string, or a list split on a specific character."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jvVe4dAKXKXq",
        "colab_type": "code",
        "colab": {},
        "outputId": "063a911b-df91-40ee-cfd2-d4b417fbed3f"
      },
      "source": [
        "firstname = 'Christopher Arthur Hansen Brooks'.split(' ')[0] # [0] selects the first element of the list\n",
        "lastname = 'Christopher Arthur Hansen Brooks'.split(' ')[-1] # [-1] selects the last element of the list\n",
        "print(firstname)\n",
        "print(lastname)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Christopher\n",
            "Brooks\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vXXvDJxIXKXu",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Make sure you convert objects to strings before concatenating."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvkoCNuBXKXv",
        "colab_type": "code",
        "colab": {},
        "outputId": "e75f0c7e-54e8-434d-9cea-a784dbcdd238"
      },
      "source": [
        "'Chris' + 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "must be str, not int",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-28-1623ac76de6e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'Chris'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4q2H44HcXKXz",
        "colab_type": "code",
        "colab": {},
        "outputId": "ac9dcc58-9a93-4824-dcf2-0aac8f98443c"
      },
      "source": [
        "'Chris' + str(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Chris2'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KElltkdwXKX4",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Dictionaries associate keys with values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gfJx5WfuXKX4",
        "colab_type": "code",
        "colab": {},
        "outputId": "1a559c2f-98cd-428d-ef2f-e6334e477ca9"
      },
      "source": [
        "x = {'Christopher Brooks': 'brooksch@umich.edu', 'Bill Gates': 'billg@microsoft.com'}\n",
        "x['Christopher Brooks'] # Retrieve a value by using the indexing operator\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'brooksch@umich.edu'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fvSTO2ViXKX8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x['Kevyn Collins-Thompson'] = None\n",
        "x['Kevyn Collins-Thompson']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wYTmgVZSXKYB",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Iterate over all of the keys:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "vO0XoHURXKYB",
        "colab_type": "code",
        "colab": {},
        "outputId": "33b24a89-d362-49fa-a127-3da3f22bdd77"
      },
      "source": [
        "for name in x:\n",
        "    print(x[name])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "brooksch@umich.edu\n",
            "billg@microsoft.com\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VuTLgAtVXKYF",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Iterate over all of the values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2NeypXsnXKYG",
        "colab_type": "code",
        "colab": {},
        "outputId": "29be3382-c889-4126-d8db-dd2017219e6e"
      },
      "source": [
        "for email in x.values():\n",
        "    print(email)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "brooksch@umich.edu\n",
            "billg@microsoft.com\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l1TrsXBcXKYJ",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Iterate over all of the items in the list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XwoBiBGIXKYK",
        "colab_type": "code",
        "colab": {},
        "outputId": "30ec7ba1-6e49-48af-a529-1a224183bf3c"
      },
      "source": [
        "for name, email in x.items():\n",
        "    print(name)\n",
        "    print(email)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Christopher Brooks\n",
            "brooksch@umich.edu\n",
            "Bill Gates\n",
            "billg@microsoft.com\n",
            "Kevyn Collins-Thompson\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4DybBYzXKYO",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "You can unpack a sequence into different variables:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RpXNahflXKYP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = ('Christopher', 'Brooks', 'brooksch@umich.edu')\n",
        "fname, lname, email = x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ASjGqs5tXKYT",
        "colab_type": "code",
        "colab": {},
        "outputId": "6a044653-cf5c-4f66-8eff-86480c148c68"
      },
      "source": [
        "fname"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Christopher'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1BMz9GJ7XKYX",
        "colab_type": "code",
        "colab": {},
        "outputId": "0382dab0-a1f3-4774-a5b2-00fed5364c03"
      },
      "source": [
        "lname"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Brooks'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z6o8ESPDXKYa",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Make sure the number of values you are unpacking matches the number of variables being assigned."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8VrQC9f4XKYb",
        "colab_type": "code",
        "colab": {},
        "outputId": "eaa65751-b0c3-4fd7-e491-7cb9834a095a"
      },
      "source": [
        "x = ('Christopher', 'Brooks', 'brooksch@umich.edu', 'Ann Arbor')\n",
        "fname, lname, email = x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "too many values to unpack (expected 3)",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-9ce70064f53e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'Christopher'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Brooks'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'brooksch@umich.edu'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Ann Arbor'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0memail\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 3)"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EWwtlUmKXKYg",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# The Python Programming Language: More on Strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sGXbN0eFXKYh",
        "colab_type": "code",
        "colab": {},
        "outputId": "9fbc4573-c7d5-4703-d76c-e6900c87da57"
      },
      "source": [
        "print('Chris' + 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "must be str, not int",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-40-82ccfdd3d5d3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Chris'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xWKUi7oCXKYn",
        "colab_type": "code",
        "colab": {},
        "outputId": "5b70cbf4-7220-4ee3-e8fe-c3dbb81503e9"
      },
      "source": [
        "print('Chris' + str(2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Chris2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q5SzQtD1XKYs",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Python has a built in method for convenient string formatting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l_e7R6OPXKYt",
        "colab_type": "code",
        "colab": {},
        "outputId": "7923bd2b-752b-46e6-96e6-5b1907722ec6"
      },
      "source": [
        "sales_record = {\n",
        "'price': 3.24,\n",
        "'num_items': 4,\n",
        "'person': 'Chris'}\n",
        "\n",
        "sales_statement = '{} bought {} item(s) at a price of {} each for a total of {}'\n",
        "\n",
        "print(sales_statement.format(sales_record['person'],\n",
        "                             sales_record['num_items'],\n",
        "                             sales_record['price'],\n",
        "                             sales_record['num_items']*sales_record['price']))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Chris bought 4 item(s) at a price of 3.24 each for a total of 12.96\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1BN6gn5jXKYz",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# Reading and Writing CSV files"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OBbYODTkXKY0",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Let's import our datafile mpg.csv, which contains fuel economy data for 234 cars.\n",
        "\n",
        "* mpg : miles per gallon\n",
        "* class : car classification\n",
        "* cty : city mpg\n",
        "* cyl : # of cylinders\n",
        "* displ : engine displacement in liters\n",
        "* drv : f = front-wheel drive, r = rear wheel drive, 4 = 4wd\n",
        "* fl : fuel (e = ethanol E85, d = diesel, r = regular, p = premium, c = CNG)\n",
        "* hwy : highway mpg\n",
        "* manufacturer : automobile manufacturer\n",
        "* model : model of car\n",
        "* trans : type of transmission\n",
        "* year : model year"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "unWDarrtXKY0",
        "colab_type": "code",
        "colab": {},
        "outputId": "23473d70-ac51-46c7-d627-dbecaaeceeed"
      },
      "source": [
        "import csv\n",
        "\n",
        "%precision 2\n",
        "\n",
        "with open('mpg.csv') as csvfile:\n",
        "    mpg = list(csv.DictReader(csvfile))\n",
        "    \n",
        "mpg[:3] # The first three dictionaries in our list."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[OrderedDict([('', '1'),\n",
              "              ('manufacturer', 'audi'),\n",
              "              ('model', 'a4'),\n",
              "              ('displ', '1.8'),\n",
              "              ('year', '1999'),\n",
              "              ('cyl', '4'),\n",
              "              ('trans', 'auto(l5)'),\n",
              "              ('drv', 'f'),\n",
              "              ('cty', '18'),\n",
              "              ('hwy', '29'),\n",
              "              ('fl', 'p'),\n",
              "              ('class', 'compact')]),\n",
              " OrderedDict([('', '2'),\n",
              "              ('manufacturer', 'audi'),\n",
              "              ('model', 'a4'),\n",
              "              ('displ', '1.8'),\n",
              "              ('year', '1999'),\n",
              "              ('cyl', '4'),\n",
              "              ('trans', 'manual(m5)'),\n",
              "              ('drv', 'f'),\n",
              "              ('cty', '21'),\n",
              "              ('hwy', '29'),\n",
              "              ('fl', 'p'),\n",
              "              ('class', 'compact')]),\n",
              " OrderedDict([('', '3'),\n",
              "              ('manufacturer', 'audi'),\n",
              "              ('model', 'a4'),\n",
              "              ('displ', '2'),\n",
              "              ('year', '2008'),\n",
              "              ('cyl', '4'),\n",
              "              ('trans', 'manual(m6)'),\n",
              "              ('drv', 'f'),\n",
              "              ('cty', '20'),\n",
              "              ('hwy', '31'),\n",
              "              ('fl', 'p'),\n",
              "              ('class', 'compact')])]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9kUokBDnXKY7",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`csv.Dictreader` has read in each row of our csv file as a dictionary. `len` shows that our list is comprised of 234 dictionaries."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cTbyVNJjXKY7",
        "colab_type": "code",
        "colab": {},
        "outputId": "e684d926-6352-49b2-e01d-947b1254bfc8"
      },
      "source": [
        "len(mpg)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "234"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NSWnZUmeXKZB",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`keys` gives us the column names of our csv."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZTJ5kLyUXKZC",
        "colab_type": "code",
        "colab": {},
        "outputId": "2e027469-d444-4114-90d9-fcc97687b27c"
      },
      "source": [
        "mpg[0].keys()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "odict_keys(['', 'manufacturer', 'model', 'displ', 'year', 'cyl', 'trans', 'drv', 'cty', 'hwy', 'fl', 'class'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P7XJWZ7vXKZL",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "This is how to find the average cty fuel economy across all cars. All values in the dictionaries are strings, so we need to convert to float."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kTASruJEXKZL",
        "colab_type": "code",
        "colab": {},
        "outputId": "803fbae4-9c0d-45b2-e8ca-97d324cd1333"
      },
      "source": [
        "sum(float(d['cty']) for d in mpg) / len(mpg)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16.86"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Jy_hQQZXKZP",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Similarly this is how to find the average hwy fuel economy across all cars."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J5MdWntpXKZQ",
        "colab_type": "code",
        "colab": {},
        "outputId": "94db2afd-1c6b-4de4-f295-337ef911e078"
      },
      "source": [
        "sum(float(d['hwy']) for d in mpg) / len(mpg)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "23.44"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V4DbiKUbXKZU",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `set` to return the unique values for the number of cylinders the cars in our dataset have."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U1b9axzXXKZV",
        "colab_type": "code",
        "colab": {},
        "outputId": "de7fdd76-b6b8-415c-912b-e51a241feb4b"
      },
      "source": [
        "cylinders = set(d['cyl'] for d in mpg)\n",
        "cylinders"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'4', '5', '6', '8'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5D0_bOoyXKZa",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Here's a more complex example where we are grouping the cars by number of cylinder, and finding the average cty mpg for each group."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QYfFessQXKZb",
        "colab_type": "code",
        "colab": {},
        "outputId": "84a865ae-b7aa-42de-8cf9-754e08d14e0b"
      },
      "source": [
        "CtyMpgByCyl = []\n",
        "\n",
        "for c in cylinders: # iterate over all the cylinder levels\n",
        "    summpg = 0\n",
        "    cyltypecount = 0\n",
        "    for d in mpg: # iterate over all dictionaries\n",
        "        if d['cyl'] == c: # if the cylinder level type matches,\n",
        "            summpg += float(d['cty']) # add the cty mpg\n",
        "            cyltypecount += 1 # increment the count\n",
        "    CtyMpgByCyl.append((c, summpg / cyltypecount)) # append the tuple ('cylinder', 'avg mpg')\n",
        "\n",
        "CtyMpgByCyl.sort(key=lambda x: x[0])\n",
        "CtyMpgByCyl"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('4', 21.01), ('5', 20.50), ('6', 16.22), ('8', 12.57)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-L_e6vmMXKZg",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `set` to return the unique values for the class types in our dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "htDUy59EXKZh",
        "colab_type": "code",
        "colab": {},
        "outputId": "c011282b-d16e-4919-c1c6-68c5813ae070"
      },
      "source": [
        "vehicleclass = set(d['class'] for d in mpg) # what are the class types\n",
        "vehicleclass"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'2seater', 'compact', 'midsize', 'minivan', 'pickup', 'subcompact', 'suv'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g8ovr1VsXKZu",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "And here's an example of how to find the average hwy mpg for each class of vehicle in our dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m8gBGQFpXKZv",
        "colab_type": "code",
        "colab": {},
        "outputId": "54649267-d856-48bd-895a-b0b7db067525"
      },
      "source": [
        "HwyMpgByClass = []\n",
        "\n",
        "for t in vehicleclass: # iterate over all the vehicle classes\n",
        "    summpg = 0\n",
        "    vclasscount = 0\n",
        "    for d in mpg: # iterate over all dictionaries\n",
        "        if d['class'] == t: # if the cylinder amount type matches,\n",
        "            summpg += float(d['hwy']) # add the hwy mpg\n",
        "            vclasscount += 1 # increment the count\n",
        "    HwyMpgByClass.append((t, summpg / vclasscount)) # append the tuple ('class', 'avg mpg')\n",
        "\n",
        "HwyMpgByClass.sort(key=lambda x: x[1])\n",
        "HwyMpgByClass"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('pickup', 16.88),\n",
              " ('suv', 18.13),\n",
              " ('minivan', 22.36),\n",
              " ('2seater', 24.80),\n",
              " ('midsize', 27.29),\n",
              " ('subcompact', 28.14),\n",
              " ('compact', 28.30)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9YpBWoQAXKZx",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# The Python Programming Language: Dates and Times"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OBV8y9TOXKZy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import datetime as dt\n",
        "import time as tm"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w8v-ZO7jXKZ5",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`time` returns the current time in seconds since the Epoch. (January 1st, 1970)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w94MURHVXKZ6",
        "colab_type": "code",
        "colab": {},
        "outputId": "d3e565dd-ef91-495c-abaf-c78e0695ba65"
      },
      "source": [
        "tm.time()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1597811721.51"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NNf7kYoSXKZ8",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Convert the timestamp to datetime."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LG_Cv0mfXKZ9",
        "colab_type": "code",
        "colab": {},
        "outputId": "4fc81abd-179b-4090-d187-9c9239050fd2"
      },
      "source": [
        "dtnow = dt.datetime.fromtimestamp(tm.time())\n",
        "dtnow"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "datetime.datetime(2020, 8, 19, 4, 37, 24, 630515)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lJ_-nRmvXKaA",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Handy datetime attributes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pYnMUC8nXKaA",
        "colab_type": "code",
        "colab": {},
        "outputId": "a0877d19-9897-4a69-89a6-8cb24af6e4eb"
      },
      "source": [
        "dtnow.year, dtnow.month, dtnow.day, dtnow.hour, dtnow.minute, dtnow.second # get year, month, day, etc.from a datetime"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2020, 8, 19, 4, 37, 24)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ar7MXHaRXKaF",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`timedelta` is a duration expressing the difference between two dates."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R-0VPWpNXKaG",
        "colab_type": "code",
        "colab": {},
        "outputId": "555e8a3a-31b9-4d3e-de41-e62c95b21ebd"
      },
      "source": [
        "delta = dt.timedelta(days = 100) # create a timedelta of 100 days\n",
        "delta"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "datetime.timedelta(100)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qIOTpZ11XKaM",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`date.today` returns the current local date."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dqgw8L-2XKaM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "today = dt.date.today()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MOpembwuXKaS",
        "colab_type": "code",
        "colab": {},
        "outputId": "209b6934-8b30-45ef-b0f8-2832706331b1"
      },
      "source": [
        "today - delta # the date 100 days ago"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "datetime.date(2020, 5, 11)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZslRnxVAXKaV",
        "colab_type": "code",
        "colab": {},
        "outputId": "9a615908-feca-460d-92ec-c87b2ba39ad7"
      },
      "source": [
        "today > today-delta # compare dates"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HMkpSodZXKaZ",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# The Python Programming Language: Objects and map()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J8NOeH7TXKaa",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "An example of a class in python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mpq1hdIRXKaa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Person:\n",
        "    department = 'School of Information' #a class variable\n",
        "\n",
        "    def set_name(self, new_name): #a method\n",
        "        self.name = new_name\n",
        "    def set_location(self, new_location):\n",
        "        self.location = new_location"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-2yIQO9iXKae",
        "colab_type": "code",
        "colab": {},
        "outputId": "d8c8b827-c4d3-402e-baf0-0c54bc90decd"
      },
      "source": [
        "person = Person()\n",
        "person.set_name('Christopher Brooks')\n",
        "person.set_location('Ann Arbor, MI, USA')\n",
        "print('{} live in {} and works in the department {}'.format(person.name, person.location, person.department))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Christopher Brooks live in Ann Arbor, MI, USA and works in the department School of Information\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJdNa-TcXKag",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Here's an example of mapping the `min` function between two lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iqmG-HWZXKag",
        "colab_type": "code",
        "colab": {},
        "outputId": "37bcf149-dce9-4806-ff15-955c2dceed3e"
      },
      "source": [
        "store1 = [10.00, 11.00, 12.34, 2.34]\n",
        "store2 = [9.00, 11.10, 12.34, 2.01]\n",
        "cheapest = map(min, store1, store2)\n",
        "cheapest"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<map at 0x7f2a801c08d0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S4_faAkAXKai",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Now let's iterate through the map object to see the values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "QmMxUAaXXKaj",
        "colab_type": "code",
        "colab": {},
        "outputId": "7ca12baf-82bf-43bd-d7ea-e1ffad04cdf7"
      },
      "source": [
        "for item in cheapest:\n",
        "    print(item)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9.0\n",
            "11.0\n",
            "12.34\n",
            "2.01\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6U9KMTkdXKal",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# The Python Programming Language: Lambda and List Comprehensions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZYey9l4XKam",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Here's an example of lambda that takes in three parameters and adds the first two."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cD4tNf5LXKam",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_function = lambda a, b, c : a + b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xIJRq2PTXKap",
        "colab_type": "code",
        "colab": {},
        "outputId": "977f51f9-0bb6-4b68-b830-f235be1d4253"
      },
      "source": [
        "my_function(1, 2, 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTx6-PK5XKau",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Let's iterate from 0 to 999 and return the even numbers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AEwrCBqOXKau",
        "colab_type": "code",
        "colab": {},
        "outputId": "4afd1689-ca6b-418a-f3f6-eb2aaf925bbe"
      },
      "source": [
        "my_list = []\n",
        "for number in range(0, 1000):\n",
        "    if number % 2 == 0:\n",
        "        my_list.append(number)\n",
        "my_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0,\n",
              " 2,\n",
              " 4,\n",
              " 6,\n",
              " 8,\n",
              " 10,\n",
              " 12,\n",
              " 14,\n",
              " 16,\n",
              " 18,\n",
              " 20,\n",
              " 22,\n",
              " 24,\n",
              " 26,\n",
              " 28,\n",
              " 30,\n",
              " 32,\n",
              " 34,\n",
              " 36,\n",
              " 38,\n",
              " 40,\n",
              " 42,\n",
              " 44,\n",
              " 46,\n",
              " 48,\n",
              " 50,\n",
              " 52,\n",
              " 54,\n",
              " 56,\n",
              " 58,\n",
              " 60,\n",
              " 62,\n",
              " 64,\n",
              " 66,\n",
              " 68,\n",
              " 70,\n",
              " 72,\n",
              " 74,\n",
              " 76,\n",
              " 78,\n",
              " 80,\n",
              " 82,\n",
              " 84,\n",
              " 86,\n",
              " 88,\n",
              " 90,\n",
              " 92,\n",
              " 94,\n",
              " 96,\n",
              " 98,\n",
              " 100,\n",
              " 102,\n",
              " 104,\n",
              " 106,\n",
              " 108,\n",
              " 110,\n",
              " 112,\n",
              " 114,\n",
              " 116,\n",
              " 118,\n",
              " 120,\n",
              " 122,\n",
              " 124,\n",
              " 126,\n",
              " 128,\n",
              " 130,\n",
              " 132,\n",
              " 134,\n",
              " 136,\n",
              " 138,\n",
              " 140,\n",
              " 142,\n",
              " 144,\n",
              " 146,\n",
              " 148,\n",
              " 150,\n",
              " 152,\n",
              " 154,\n",
              " 156,\n",
              " 158,\n",
              " 160,\n",
              " 162,\n",
              " 164,\n",
              " 166,\n",
              " 168,\n",
              " 170,\n",
              " 172,\n",
              " 174,\n",
              " 176,\n",
              " 178,\n",
              " 180,\n",
              " 182,\n",
              " 184,\n",
              " 186,\n",
              " 188,\n",
              " 190,\n",
              " 192,\n",
              " 194,\n",
              " 196,\n",
              " 198,\n",
              " 200,\n",
              " 202,\n",
              " 204,\n",
              " 206,\n",
              " 208,\n",
              " 210,\n",
              " 212,\n",
              " 214,\n",
              " 216,\n",
              " 218,\n",
              " 220,\n",
              " 222,\n",
              " 224,\n",
              " 226,\n",
              " 228,\n",
              " 230,\n",
              " 232,\n",
              " 234,\n",
              " 236,\n",
              " 238,\n",
              " 240,\n",
              " 242,\n",
              " 244,\n",
              " 246,\n",
              " 248,\n",
              " 250,\n",
              " 252,\n",
              " 254,\n",
              " 256,\n",
              " 258,\n",
              " 260,\n",
              " 262,\n",
              " 264,\n",
              " 266,\n",
              " 268,\n",
              " 270,\n",
              " 272,\n",
              " 274,\n",
              " 276,\n",
              " 278,\n",
              " 280,\n",
              " 282,\n",
              " 284,\n",
              " 286,\n",
              " 288,\n",
              " 290,\n",
              " 292,\n",
              " 294,\n",
              " 296,\n",
              " 298,\n",
              " 300,\n",
              " 302,\n",
              " 304,\n",
              " 306,\n",
              " 308,\n",
              " 310,\n",
              " 312,\n",
              " 314,\n",
              " 316,\n",
              " 318,\n",
              " 320,\n",
              " 322,\n",
              " 324,\n",
              " 326,\n",
              " 328,\n",
              " 330,\n",
              " 332,\n",
              " 334,\n",
              " 336,\n",
              " 338,\n",
              " 340,\n",
              " 342,\n",
              " 344,\n",
              " 346,\n",
              " 348,\n",
              " 350,\n",
              " 352,\n",
              " 354,\n",
              " 356,\n",
              " 358,\n",
              " 360,\n",
              " 362,\n",
              " 364,\n",
              " 366,\n",
              " 368,\n",
              " 370,\n",
              " 372,\n",
              " 374,\n",
              " 376,\n",
              " 378,\n",
              " 380,\n",
              " 382,\n",
              " 384,\n",
              " 386,\n",
              " 388,\n",
              " 390,\n",
              " 392,\n",
              " 394,\n",
              " 396,\n",
              " 398,\n",
              " 400,\n",
              " 402,\n",
              " 404,\n",
              " 406,\n",
              " 408,\n",
              " 410,\n",
              " 412,\n",
              " 414,\n",
              " 416,\n",
              " 418,\n",
              " 420,\n",
              " 422,\n",
              " 424,\n",
              " 426,\n",
              " 428,\n",
              " 430,\n",
              " 432,\n",
              " 434,\n",
              " 436,\n",
              " 438,\n",
              " 440,\n",
              " 442,\n",
              " 444,\n",
              " 446,\n",
              " 448,\n",
              " 450,\n",
              " 452,\n",
              " 454,\n",
              " 456,\n",
              " 458,\n",
              " 460,\n",
              " 462,\n",
              " 464,\n",
              " 466,\n",
              " 468,\n",
              " 470,\n",
              " 472,\n",
              " 474,\n",
              " 476,\n",
              " 478,\n",
              " 480,\n",
              " 482,\n",
              " 484,\n",
              " 486,\n",
              " 488,\n",
              " 490,\n",
              " 492,\n",
              " 494,\n",
              " 496,\n",
              " 498,\n",
              " 500,\n",
              " 502,\n",
              " 504,\n",
              " 506,\n",
              " 508,\n",
              " 510,\n",
              " 512,\n",
              " 514,\n",
              " 516,\n",
              " 518,\n",
              " 520,\n",
              " 522,\n",
              " 524,\n",
              " 526,\n",
              " 528,\n",
              " 530,\n",
              " 532,\n",
              " 534,\n",
              " 536,\n",
              " 538,\n",
              " 540,\n",
              " 542,\n",
              " 544,\n",
              " 546,\n",
              " 548,\n",
              " 550,\n",
              " 552,\n",
              " 554,\n",
              " 556,\n",
              " 558,\n",
              " 560,\n",
              " 562,\n",
              " 564,\n",
              " 566,\n",
              " 568,\n",
              " 570,\n",
              " 572,\n",
              " 574,\n",
              " 576,\n",
              " 578,\n",
              " 580,\n",
              " 582,\n",
              " 584,\n",
              " 586,\n",
              " 588,\n",
              " 590,\n",
              " 592,\n",
              " 594,\n",
              " 596,\n",
              " 598,\n",
              " 600,\n",
              " 602,\n",
              " 604,\n",
              " 606,\n",
              " 608,\n",
              " 610,\n",
              " 612,\n",
              " 614,\n",
              " 616,\n",
              " 618,\n",
              " 620,\n",
              " 622,\n",
              " 624,\n",
              " 626,\n",
              " 628,\n",
              " 630,\n",
              " 632,\n",
              " 634,\n",
              " 636,\n",
              " 638,\n",
              " 640,\n",
              " 642,\n",
              " 644,\n",
              " 646,\n",
              " 648,\n",
              " 650,\n",
              " 652,\n",
              " 654,\n",
              " 656,\n",
              " 658,\n",
              " 660,\n",
              " 662,\n",
              " 664,\n",
              " 666,\n",
              " 668,\n",
              " 670,\n",
              " 672,\n",
              " 674,\n",
              " 676,\n",
              " 678,\n",
              " 680,\n",
              " 682,\n",
              " 684,\n",
              " 686,\n",
              " 688,\n",
              " 690,\n",
              " 692,\n",
              " 694,\n",
              " 696,\n",
              " 698,\n",
              " 700,\n",
              " 702,\n",
              " 704,\n",
              " 706,\n",
              " 708,\n",
              " 710,\n",
              " 712,\n",
              " 714,\n",
              " 716,\n",
              " 718,\n",
              " 720,\n",
              " 722,\n",
              " 724,\n",
              " 726,\n",
              " 728,\n",
              " 730,\n",
              " 732,\n",
              " 734,\n",
              " 736,\n",
              " 738,\n",
              " 740,\n",
              " 742,\n",
              " 744,\n",
              " 746,\n",
              " 748,\n",
              " 750,\n",
              " 752,\n",
              " 754,\n",
              " 756,\n",
              " 758,\n",
              " 760,\n",
              " 762,\n",
              " 764,\n",
              " 766,\n",
              " 768,\n",
              " 770,\n",
              " 772,\n",
              " 774,\n",
              " 776,\n",
              " 778,\n",
              " 780,\n",
              " 782,\n",
              " 784,\n",
              " 786,\n",
              " 788,\n",
              " 790,\n",
              " 792,\n",
              " 794,\n",
              " 796,\n",
              " 798,\n",
              " 800,\n",
              " 802,\n",
              " 804,\n",
              " 806,\n",
              " 808,\n",
              " 810,\n",
              " 812,\n",
              " 814,\n",
              " 816,\n",
              " 818,\n",
              " 820,\n",
              " 822,\n",
              " 824,\n",
              " 826,\n",
              " 828,\n",
              " 830,\n",
              " 832,\n",
              " 834,\n",
              " 836,\n",
              " 838,\n",
              " 840,\n",
              " 842,\n",
              " 844,\n",
              " 846,\n",
              " 848,\n",
              " 850,\n",
              " 852,\n",
              " 854,\n",
              " 856,\n",
              " 858,\n",
              " 860,\n",
              " 862,\n",
              " 864,\n",
              " 866,\n",
              " 868,\n",
              " 870,\n",
              " 872,\n",
              " 874,\n",
              " 876,\n",
              " 878,\n",
              " 880,\n",
              " 882,\n",
              " 884,\n",
              " 886,\n",
              " 888,\n",
              " 890,\n",
              " 892,\n",
              " 894,\n",
              " 896,\n",
              " 898,\n",
              " 900,\n",
              " 902,\n",
              " 904,\n",
              " 906,\n",
              " 908,\n",
              " 910,\n",
              " 912,\n",
              " 914,\n",
              " 916,\n",
              " 918,\n",
              " 920,\n",
              " 922,\n",
              " 924,\n",
              " 926,\n",
              " 928,\n",
              " 930,\n",
              " 932,\n",
              " 934,\n",
              " 936,\n",
              " 938,\n",
              " 940,\n",
              " 942,\n",
              " 944,\n",
              " 946,\n",
              " 948,\n",
              " 950,\n",
              " 952,\n",
              " 954,\n",
              " 956,\n",
              " 958,\n",
              " 960,\n",
              " 962,\n",
              " 964,\n",
              " 966,\n",
              " 968,\n",
              " 970,\n",
              " 972,\n",
              " 974,\n",
              " 976,\n",
              " 978,\n",
              " 980,\n",
              " 982,\n",
              " 984,\n",
              " 986,\n",
              " 988,\n",
              " 990,\n",
              " 992,\n",
              " 994,\n",
              " 996,\n",
              " 998]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uzSVRNXAXKaw",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Now the same thing but with list comprehension."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-mF8oJoDXKax",
        "colab_type": "code",
        "colab": {},
        "outputId": "e0b1f5e7-33c5-4582-b1ee-58668334623a"
      },
      "source": [
        "my_list = [number for number in range(0,1000) if number % 2 == 0]\n",
        "my_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0,\n",
              " 2,\n",
              " 4,\n",
              " 6,\n",
              " 8,\n",
              " 10,\n",
              " 12,\n",
              " 14,\n",
              " 16,\n",
              " 18,\n",
              " 20,\n",
              " 22,\n",
              " 24,\n",
              " 26,\n",
              " 28,\n",
              " 30,\n",
              " 32,\n",
              " 34,\n",
              " 36,\n",
              " 38,\n",
              " 40,\n",
              " 42,\n",
              " 44,\n",
              " 46,\n",
              " 48,\n",
              " 50,\n",
              " 52,\n",
              " 54,\n",
              " 56,\n",
              " 58,\n",
              " 60,\n",
              " 62,\n",
              " 64,\n",
              " 66,\n",
              " 68,\n",
              " 70,\n",
              " 72,\n",
              " 74,\n",
              " 76,\n",
              " 78,\n",
              " 80,\n",
              " 82,\n",
              " 84,\n",
              " 86,\n",
              " 88,\n",
              " 90,\n",
              " 92,\n",
              " 94,\n",
              " 96,\n",
              " 98,\n",
              " 100,\n",
              " 102,\n",
              " 104,\n",
              " 106,\n",
              " 108,\n",
              " 110,\n",
              " 112,\n",
              " 114,\n",
              " 116,\n",
              " 118,\n",
              " 120,\n",
              " 122,\n",
              " 124,\n",
              " 126,\n",
              " 128,\n",
              " 130,\n",
              " 132,\n",
              " 134,\n",
              " 136,\n",
              " 138,\n",
              " 140,\n",
              " 142,\n",
              " 144,\n",
              " 146,\n",
              " 148,\n",
              " 150,\n",
              " 152,\n",
              " 154,\n",
              " 156,\n",
              " 158,\n",
              " 160,\n",
              " 162,\n",
              " 164,\n",
              " 166,\n",
              " 168,\n",
              " 170,\n",
              " 172,\n",
              " 174,\n",
              " 176,\n",
              " 178,\n",
              " 180,\n",
              " 182,\n",
              " 184,\n",
              " 186,\n",
              " 188,\n",
              " 190,\n",
              " 192,\n",
              " 194,\n",
              " 196,\n",
              " 198,\n",
              " 200,\n",
              " 202,\n",
              " 204,\n",
              " 206,\n",
              " 208,\n",
              " 210,\n",
              " 212,\n",
              " 214,\n",
              " 216,\n",
              " 218,\n",
              " 220,\n",
              " 222,\n",
              " 224,\n",
              " 226,\n",
              " 228,\n",
              " 230,\n",
              " 232,\n",
              " 234,\n",
              " 236,\n",
              " 238,\n",
              " 240,\n",
              " 242,\n",
              " 244,\n",
              " 246,\n",
              " 248,\n",
              " 250,\n",
              " 252,\n",
              " 254,\n",
              " 256,\n",
              " 258,\n",
              " 260,\n",
              " 262,\n",
              " 264,\n",
              " 266,\n",
              " 268,\n",
              " 270,\n",
              " 272,\n",
              " 274,\n",
              " 276,\n",
              " 278,\n",
              " 280,\n",
              " 282,\n",
              " 284,\n",
              " 286,\n",
              " 288,\n",
              " 290,\n",
              " 292,\n",
              " 294,\n",
              " 296,\n",
              " 298,\n",
              " 300,\n",
              " 302,\n",
              " 304,\n",
              " 306,\n",
              " 308,\n",
              " 310,\n",
              " 312,\n",
              " 314,\n",
              " 316,\n",
              " 318,\n",
              " 320,\n",
              " 322,\n",
              " 324,\n",
              " 326,\n",
              " 328,\n",
              " 330,\n",
              " 332,\n",
              " 334,\n",
              " 336,\n",
              " 338,\n",
              " 340,\n",
              " 342,\n",
              " 344,\n",
              " 346,\n",
              " 348,\n",
              " 350,\n",
              " 352,\n",
              " 354,\n",
              " 356,\n",
              " 358,\n",
              " 360,\n",
              " 362,\n",
              " 364,\n",
              " 366,\n",
              " 368,\n",
              " 370,\n",
              " 372,\n",
              " 374,\n",
              " 376,\n",
              " 378,\n",
              " 380,\n",
              " 382,\n",
              " 384,\n",
              " 386,\n",
              " 388,\n",
              " 390,\n",
              " 392,\n",
              " 394,\n",
              " 396,\n",
              " 398,\n",
              " 400,\n",
              " 402,\n",
              " 404,\n",
              " 406,\n",
              " 408,\n",
              " 410,\n",
              " 412,\n",
              " 414,\n",
              " 416,\n",
              " 418,\n",
              " 420,\n",
              " 422,\n",
              " 424,\n",
              " 426,\n",
              " 428,\n",
              " 430,\n",
              " 432,\n",
              " 434,\n",
              " 436,\n",
              " 438,\n",
              " 440,\n",
              " 442,\n",
              " 444,\n",
              " 446,\n",
              " 448,\n",
              " 450,\n",
              " 452,\n",
              " 454,\n",
              " 456,\n",
              " 458,\n",
              " 460,\n",
              " 462,\n",
              " 464,\n",
              " 466,\n",
              " 468,\n",
              " 470,\n",
              " 472,\n",
              " 474,\n",
              " 476,\n",
              " 478,\n",
              " 480,\n",
              " 482,\n",
              " 484,\n",
              " 486,\n",
              " 488,\n",
              " 490,\n",
              " 492,\n",
              " 494,\n",
              " 496,\n",
              " 498,\n",
              " 500,\n",
              " 502,\n",
              " 504,\n",
              " 506,\n",
              " 508,\n",
              " 510,\n",
              " 512,\n",
              " 514,\n",
              " 516,\n",
              " 518,\n",
              " 520,\n",
              " 522,\n",
              " 524,\n",
              " 526,\n",
              " 528,\n",
              " 530,\n",
              " 532,\n",
              " 534,\n",
              " 536,\n",
              " 538,\n",
              " 540,\n",
              " 542,\n",
              " 544,\n",
              " 546,\n",
              " 548,\n",
              " 550,\n",
              " 552,\n",
              " 554,\n",
              " 556,\n",
              " 558,\n",
              " 560,\n",
              " 562,\n",
              " 564,\n",
              " 566,\n",
              " 568,\n",
              " 570,\n",
              " 572,\n",
              " 574,\n",
              " 576,\n",
              " 578,\n",
              " 580,\n",
              " 582,\n",
              " 584,\n",
              " 586,\n",
              " 588,\n",
              " 590,\n",
              " 592,\n",
              " 594,\n",
              " 596,\n",
              " 598,\n",
              " 600,\n",
              " 602,\n",
              " 604,\n",
              " 606,\n",
              " 608,\n",
              " 610,\n",
              " 612,\n",
              " 614,\n",
              " 616,\n",
              " 618,\n",
              " 620,\n",
              " 622,\n",
              " 624,\n",
              " 626,\n",
              " 628,\n",
              " 630,\n",
              " 632,\n",
              " 634,\n",
              " 636,\n",
              " 638,\n",
              " 640,\n",
              " 642,\n",
              " 644,\n",
              " 646,\n",
              " 648,\n",
              " 650,\n",
              " 652,\n",
              " 654,\n",
              " 656,\n",
              " 658,\n",
              " 660,\n",
              " 662,\n",
              " 664,\n",
              " 666,\n",
              " 668,\n",
              " 670,\n",
              " 672,\n",
              " 674,\n",
              " 676,\n",
              " 678,\n",
              " 680,\n",
              " 682,\n",
              " 684,\n",
              " 686,\n",
              " 688,\n",
              " 690,\n",
              " 692,\n",
              " 694,\n",
              " 696,\n",
              " 698,\n",
              " 700,\n",
              " 702,\n",
              " 704,\n",
              " 706,\n",
              " 708,\n",
              " 710,\n",
              " 712,\n",
              " 714,\n",
              " 716,\n",
              " 718,\n",
              " 720,\n",
              " 722,\n",
              " 724,\n",
              " 726,\n",
              " 728,\n",
              " 730,\n",
              " 732,\n",
              " 734,\n",
              " 736,\n",
              " 738,\n",
              " 740,\n",
              " 742,\n",
              " 744,\n",
              " 746,\n",
              " 748,\n",
              " 750,\n",
              " 752,\n",
              " 754,\n",
              " 756,\n",
              " 758,\n",
              " 760,\n",
              " 762,\n",
              " 764,\n",
              " 766,\n",
              " 768,\n",
              " 770,\n",
              " 772,\n",
              " 774,\n",
              " 776,\n",
              " 778,\n",
              " 780,\n",
              " 782,\n",
              " 784,\n",
              " 786,\n",
              " 788,\n",
              " 790,\n",
              " 792,\n",
              " 794,\n",
              " 796,\n",
              " 798,\n",
              " 800,\n",
              " 802,\n",
              " 804,\n",
              " 806,\n",
              " 808,\n",
              " 810,\n",
              " 812,\n",
              " 814,\n",
              " 816,\n",
              " 818,\n",
              " 820,\n",
              " 822,\n",
              " 824,\n",
              " 826,\n",
              " 828,\n",
              " 830,\n",
              " 832,\n",
              " 834,\n",
              " 836,\n",
              " 838,\n",
              " 840,\n",
              " 842,\n",
              " 844,\n",
              " 846,\n",
              " 848,\n",
              " 850,\n",
              " 852,\n",
              " 854,\n",
              " 856,\n",
              " 858,\n",
              " 860,\n",
              " 862,\n",
              " 864,\n",
              " 866,\n",
              " 868,\n",
              " 870,\n",
              " 872,\n",
              " 874,\n",
              " 876,\n",
              " 878,\n",
              " 880,\n",
              " 882,\n",
              " 884,\n",
              " 886,\n",
              " 888,\n",
              " 890,\n",
              " 892,\n",
              " 894,\n",
              " 896,\n",
              " 898,\n",
              " 900,\n",
              " 902,\n",
              " 904,\n",
              " 906,\n",
              " 908,\n",
              " 910,\n",
              " 912,\n",
              " 914,\n",
              " 916,\n",
              " 918,\n",
              " 920,\n",
              " 922,\n",
              " 924,\n",
              " 926,\n",
              " 928,\n",
              " 930,\n",
              " 932,\n",
              " 934,\n",
              " 936,\n",
              " 938,\n",
              " 940,\n",
              " 942,\n",
              " 944,\n",
              " 946,\n",
              " 948,\n",
              " 950,\n",
              " 952,\n",
              " 954,\n",
              " 956,\n",
              " 958,\n",
              " 960,\n",
              " 962,\n",
              " 964,\n",
              " 966,\n",
              " 968,\n",
              " 970,\n",
              " 972,\n",
              " 974,\n",
              " 976,\n",
              " 978,\n",
              " 980,\n",
              " 982,\n",
              " 984,\n",
              " 986,\n",
              " 988,\n",
              " 990,\n",
              " 992,\n",
              " 994,\n",
              " 996,\n",
              " 998]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "CoWIYHWVXKaz",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "# The Python Programming Language: Numerical Python (NumPy)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XGlVZZrFXKaz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rVWrFNb-XKa1",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "## Creating Arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xvj6E0BUXKa2",
        "colab_type": "text"
      },
      "source": [
        "Create a list and convert it to a numpy array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ECm0RWJhXKa2",
        "colab_type": "code",
        "colab": {},
        "outputId": "6fb66ebe-9c40-49dc-f567-612d4d4d6944"
      },
      "source": [
        "mylist = [1, 2, 3]\n",
        "x = np.array(mylist)\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z7-V70g6XKa5",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Or just pass in a list directly"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "frlOxCVrXKa6",
        "colab_type": "code",
        "colab": {},
        "outputId": "5c7c799b-f887-43d8-dec3-bd2e429b22eb"
      },
      "source": [
        "y = np.array([4, 5, 6])\n",
        "y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4, 5, 6])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z1i_SLntXKa9",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Pass in a list of lists to create a multidimensional array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dGB_DbkGXKa9",
        "colab_type": "code",
        "colab": {},
        "outputId": "16eac069-3901-4007-d18e-4a01044bc9b8"
      },
      "source": [
        "m = np.array([[7, 8, 9], [10, 11, 12]])\n",
        "m"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 7,  8,  9],\n",
              "       [10, 11, 12]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pf32s_1fXKa_",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use the shape method to find the dimensions of the array. (rows, columns)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Vprnu76XKbA",
        "colab_type": "code",
        "colab": {},
        "outputId": "aabe7d7b-ea27-4f3f-811d-5fdc773d92ab"
      },
      "source": [
        "m.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ya1jzLtiXKbD",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`arange` returns evenly spaced values within a given interval."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FDxpxGk5XKbE",
        "colab_type": "code",
        "colab": {},
        "outputId": "78eeb3f7-4520-4537-a179-9d8df11fbf4c"
      },
      "source": [
        "n = np.arange(0, 30, 2) # start at 0 count up by 2, stop before 30\n",
        "n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g2WTucg1XKbH",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`reshape` returns an array with the same data with a new shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y0cIDtwRXKbM",
        "colab_type": "code",
        "colab": {},
        "outputId": "074c0ba5-2291-4bf0-a627-3f41e0c3ed67"
      },
      "source": [
        "n = n.reshape(3, 5) # reshape array to be 3x5\n",
        "n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  2,  4,  6,  8],\n",
              "       [10, 12, 14, 16, 18],\n",
              "       [20, 22, 24, 26, 28]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1_nM-qX1XKbU",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`linspace` returns evenly spaced numbers over a specified interval."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dZLds5HmXKbU",
        "colab_type": "code",
        "colab": {},
        "outputId": "df9fbee5-3d5c-406f-d57e-c6693f31b061"
      },
      "source": [
        "o = np.linspace(0, 4, 9) # return 9 evenly spaced values from 0 to 4\n",
        "o"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RIkdat63XKbY",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`resize` changes the shape and size of array in-place."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RaIteH_UXKbZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "48a49df5-3719-4c75-9492-ce23e051011b"
      },
      "source": [
        "o.resize(3, 3)\n",
        "o"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0. ,  0.5,  1. ],\n",
              "       [ 1.5,  2. ,  2.5],\n",
              "       [ 3. ,  3.5,  4. ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WPJx0BPJXKbg",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`ones` returns a new array of given shape and type, filled with ones."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zQU5YjFtXKbg",
        "colab_type": "code",
        "colab": {},
        "outputId": "246114b4-6bf3-49e6-8f9a-332ea4338eb1"
      },
      "source": [
        "np.ones((3, 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.,  1.],\n",
              "       [ 1.,  1.],\n",
              "       [ 1.,  1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D75kmM4qXKbi",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`zeros` returns a new array of given shape and type, filled with zeros."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKcCbOxNXKbj",
        "colab_type": "code",
        "colab": {},
        "outputId": "e3feabc2-61e6-485e-cb39-8e8c42f6cb0b"
      },
      "source": [
        "np.zeros((2, 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0.,  0.,  0.],\n",
              "       [ 0.,  0.,  0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2HIHjkL6XKbm",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`eye` returns a 2-D array with ones on the diagonal and zeros elsewhere."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DGqY8vngXKbn",
        "colab_type": "code",
        "colab": {},
        "outputId": "71e507c5-fc82-4313-af96-2155e8a36796"
      },
      "source": [
        "np.eye(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.,  0.,  0.],\n",
              "       [ 0.,  1.,  0.],\n",
              "       [ 0.,  0.,  1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puHZCga5XKbq",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`diag` extracts a diagonal or constructs a diagonal array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zy13lr6EXKbq",
        "colab_type": "code",
        "colab": {},
        "outputId": "f792e9c0-fa9b-4eb1-f3d1-ac223164e13d"
      },
      "source": [
        "np.diag(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4, 0, 0],\n",
              "       [0, 5, 0],\n",
              "       [0, 0, 6]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3-DfjVlyXKbu",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Create an array using repeating list (or see `np.tile`)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vJtY1PVDXKbu",
        "colab_type": "code",
        "colab": {},
        "outputId": "2875b364-5321-4971-b3d9-883a9b304474"
      },
      "source": [
        "np.array([1, 2, 3] * 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 1, 2, 3, 1, 2, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pv9vWYdaXKbw",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Repeat elements of an array using `repeat`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oHSJJD-sXKbx",
        "colab_type": "code",
        "colab": {},
        "outputId": "a99fbace-d3dd-424f-8203-a7a8035a7e9d"
      },
      "source": [
        "np.repeat([1, 2, 3], 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 1, 1, 2, 2, 2, 3, 3, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gaifi5SXXKby",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "#### Combining Arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d7g3Q5TWXKbz",
        "colab_type": "code",
        "colab": {},
        "outputId": "e3773411-7fa9-4174-bffd-2979c9c5ff8f"
      },
      "source": [
        "p = np.ones([2, 3], int)\n",
        "p"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 1, 1],\n",
              "       [1, 1, 1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WjUrGLUbXKb1",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `vstack` to stack arrays in sequence vertically (row wise)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TDCMkUriXKb2",
        "colab_type": "code",
        "colab": {},
        "outputId": "ec0f2386-7fc6-4606-8626-1d676e792431"
      },
      "source": [
        "np.vstack([p, 2*p])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 1, 1],\n",
              "       [1, 1, 1],\n",
              "       [2, 2, 2],\n",
              "       [2, 2, 2]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5TRtkxLoXKb4",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `hstack` to stack arrays in sequence horizontally (column wise)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BNB9E1MKXKb5",
        "colab_type": "code",
        "colab": {},
        "outputId": "33157947-e886-4d03-abb9-eddf8c6d15e2"
      },
      "source": [
        "np.hstack([p, 2*p])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 1, 1, 2, 2, 2],\n",
              "       [1, 1, 1, 2, 2, 2]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4oAP0fpeXKb-",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "## Operations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHWhmcAuXKcB",
        "colab_type": "text"
      },
      "source": [
        "Use `+`, `-`, `*`, `/` and `**` to perform element wise addition, subtraction, multiplication, division and power."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BTxrvBtBXKcB",
        "colab_type": "code",
        "colab": {},
        "outputId": "9ab16193-1801-409e-b88a-afbdfcf5cb20"
      },
      "source": [
        "print(x + y) # elementwise addition     [1 2 3] + [4 5 6] = [5  7  9]\n",
        "print(x - y) # elementwise subtraction  [1 2 3] - [4 5 6] = [-3 -3 -3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5 7 9]\n",
            "[-3 -3 -3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Hs_3p7-XKcD",
        "colab_type": "code",
        "colab": {},
        "outputId": "9dc6294f-c3c0-4bfb-86d9-e5864abadfde"
      },
      "source": [
        "print(x * y) # elementwise multiplication  [1 2 3] * [4 5 6] = [4  10  18]\n",
        "print(x / y) # elementwise divison         [1 2 3] / [4 5 6] = [0.25  0.4  0.5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 4 10 18]\n",
            "[ 0.25  0.4   0.5 ]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7L_5XcaUXKcI",
        "colab_type": "code",
        "colab": {},
        "outputId": "15f2168b-ace9-4dc7-f34e-e5c2e2fa57c3"
      },
      "source": [
        "print(x**2) # elementwise power  [1 2 3] ^2 =  [1 4 9]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 4 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bERgwE9NXKcM",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "**Dot Product:**  \n",
        "\n",
        "$ \\begin{bmatrix}x_1 \\ x_2 \\ x_3\\end{bmatrix}\n",
        "\\cdot\n",
        "\\begin{bmatrix}y_1 \\\\ y_2 \\\\ y_3\\end{bmatrix}\n",
        "= x_1 y_1 + x_2 y_2 + x_3 y_3$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uQT5EQOwXKcN",
        "colab_type": "code",
        "colab": {},
        "outputId": "f8362994-82c7-4c71-9a08-9f4e216556eb"
      },
      "source": [
        "x.dot(y) # dot product  1*4 + 2*5 + 3*6"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q5FSV1L6XKcP",
        "colab_type": "code",
        "colab": {},
        "outputId": "7055619f-13f5-4648-f38d-26330f4fb511"
      },
      "source": [
        "z = np.array([y, y**2])\n",
        "print(len(z)) # number of rows of array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eJFyzwzKXKcV",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Let's look at transposing arrays. Transposing permutes the dimensions of the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k3k29aXWXKcV",
        "colab_type": "code",
        "colab": {},
        "outputId": "54822438-b73f-48af-e751-8ef9ff3e2ce7"
      },
      "source": [
        "z = np.array([y, y**2])\n",
        "z"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 4,  5,  6],\n",
              "       [16, 25, 36]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NS-opiaMXKcX",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "The shape of array `z` is `(2,3)` before transposing."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0B7_Y_bJXKcX",
        "colab_type": "code",
        "colab": {},
        "outputId": "666c5c9f-07f7-4c3d-a333-f4a7ed521a0e"
      },
      "source": [
        "z.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "207pBxl4XKcZ",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `.T` to get the transpose."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9BPTsgOHXKcZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "6742f468-8310-444b-85cd-2bb6a2915081"
      },
      "source": [
        "z.T"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 4, 16],\n",
              "       [ 5, 25],\n",
              "       [ 6, 36]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IxEuss4hXKcc",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "The number of rows has swapped with the number of columns."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3_-m6UBMXKcd",
        "colab_type": "code",
        "colab": {},
        "outputId": "e5ec883f-a9a9-4b10-d405-395cd987b753"
      },
      "source": [
        "z.T.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oeQ8i5SfXKcf",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `.dtype` to see the data type of the elements in the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MB_kEk2AXKcf",
        "colab_type": "code",
        "colab": {},
        "outputId": "c01ad3aa-9bd0-4f1c-9cc2-afae3b6b13cd"
      },
      "source": [
        "z.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMERljWGXKcg",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `.astype` to cast to a specific type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5XpYj4NOXKch",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z = z.astype('f')\n",
        "z.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "85_csN1FXKck",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "## Math Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CCukg_l-XKck",
        "colab_type": "text"
      },
      "source": [
        "Numpy has many built in math functions that can be performed on arrays."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6ivr1InXKcl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = np.array([-4, -2, 1, 3, 5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aKTE7vS9XKcn",
        "colab_type": "code",
        "colab": {},
        "outputId": "92bc1ca9-94ce-4387-80d4-cb687fdd2edf"
      },
      "source": [
        "a.sum()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yGUNQtWpXKcs",
        "colab_type": "code",
        "colab": {},
        "outputId": "6ec9e1bf-103b-48ef-9f06-9803d7ec70ba"
      },
      "source": [
        "a.max()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PWCTiEotXKcw",
        "colab_type": "code",
        "colab": {},
        "outputId": "8ff65b1a-f710-4fd2-9643-c08a7fce7413"
      },
      "source": [
        "a.min()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xryktzoXKcx",
        "colab_type": "code",
        "colab": {},
        "outputId": "6d2a6ff6-addc-4b3e-a70f-48badc837e32"
      },
      "source": [
        "a.mean()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.60"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i-BIAlspXKc2",
        "colab_type": "code",
        "colab": {},
        "outputId": "c1b5872d-183d-414c-fd2f-ca44c43b5482"
      },
      "source": [
        "a.std()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.26"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "REw6_ikXXKc4",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`argmax` and `argmin` return the index of the maximum and minimum values in the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O18fVFhGXKc4",
        "colab_type": "code",
        "colab": {},
        "outputId": "fed1f01f-fdbd-4c41-f25e-a0dd5bbfa465"
      },
      "source": [
        "a.argmax()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rd7RzNDFXKc5",
        "colab_type": "code",
        "colab": {},
        "outputId": "a78ed451-c00e-4ee7-81f6-607e732ee547"
      },
      "source": [
        "a.argmin()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l4RvEk1gXKc6",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "## Indexing / Slicing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C83UR-h-XKc7",
        "colab_type": "code",
        "colab": {},
        "outputId": "75a70305-2bdf-46f2-e142-4103b306e364"
      },
      "source": [
        "s = np.arange(13)**2\n",
        "s"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([  0,   1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CJKrXZwYXKc9",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use bracket notation to get the value at a specific index. Remember that indexing starts at 0."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jNz7ArsoXKc9",
        "colab_type": "code",
        "colab": {},
        "outputId": "e51326fa-9916-4cc8-b810-53cbe40d0c42"
      },
      "source": [
        "s[0], s[4], s[-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0, 16, 144)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LNtotscdXKc_",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `:` to indicate a range. `array[start:stop]`\n",
        "\n",
        "\n",
        "Leaving `start` or `stop` empty will default to the beginning/end of the array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5fNNRokPXKc_",
        "colab_type": "code",
        "colab": {},
        "outputId": "51cade99-1caf-44d2-b9ff-4290aeeb68f6"
      },
      "source": [
        "s[1:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  4,  9, 16])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "frvG7Zw7XKdB",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use negatives to count from the back."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8juUC-K1XKdC",
        "colab_type": "code",
        "colab": {},
        "outputId": "2873c621-b185-4e7b-8350-ec4e6a08fb67"
      },
      "source": [
        "s[-4:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 81, 100, 121, 144])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vEBXRjq3XKdD",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "A second `:` can be used to indicate step-size. `array[start:stop:stepsize]`\n",
        "\n",
        "Here we are starting 5th element from the end, and counting backwards by 2 until the beginning of the array is reached."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AcC-0xP6XKdE",
        "colab_type": "code",
        "colab": {},
        "outputId": "a83cf825-d7b7-46d7-dff9-13cd916e0eb0"
      },
      "source": [
        "s[-5::-2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([64, 36, 16,  4,  0])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sDqssHcNXKdG",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Let's look at a multidimensional array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n7eHonZLXKdG",
        "colab_type": "code",
        "colab": {},
        "outputId": "ca68c21a-eae7-4ec9-abea-d464b5c1946f"
      },
      "source": [
        "r = np.arange(36)\n",
        "r.resize((6, 6))\n",
        "r"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4,  5],\n",
              "       [ 6,  7,  8,  9, 10, 11],\n",
              "       [12, 13, 14, 15, 16, 17],\n",
              "       [18, 19, 20, 21, 22, 23],\n",
              "       [24, 25, 26, 27, 28, 29],\n",
              "       [30, 31, 32, 33, 34, 35]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "83wGItaCXKdK",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use bracket notation to slice: `array[row, column]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RPiaDqn1XKdK",
        "colab_type": "code",
        "colab": {},
        "outputId": "155650dd-ea91-4066-a35e-dc8d9b0e3681"
      },
      "source": [
        "r[2, 2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 119
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WYrN0NkdXKdM",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "And use : to select a range of rows or columns"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lX_Y_cIXXKdN",
        "colab_type": "code",
        "colab": {},
        "outputId": "e229ecc1-c7e1-4489-beb2-fccf32870b75"
      },
      "source": [
        "r[3, 3:6]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([21, 22, 23])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yRApByQaXKdP",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Here we are selecting all the rows up to (and not including) row 2, and all the columns up to (and not including) the last column."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aD_zu4-GXKdR",
        "colab_type": "code",
        "colab": {},
        "outputId": "3b636b8f-3307-49ef-957c-fcbb4400f4ef"
      },
      "source": [
        "r[:2, :-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4],\n",
              "       [ 6,  7,  8,  9, 10]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R3FIiGLIXKdT",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "This is a slice of the last row, and only every other element."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g_O3_hzQXKdT",
        "colab_type": "code",
        "colab": {},
        "outputId": "b624ae81-beda-480b-93cd-3f3c0488badd"
      },
      "source": [
        "r[-1, ::2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([30, 32, 34])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zU3Bu75dXKdV",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "We can also perform conditional indexing. Here we are selecting values from the array that are greater than 30. (Also see `np.where`)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tNKd3HRAXKdW",
        "colab_type": "code",
        "colab": {},
        "outputId": "7a695ba4-bf97-4235-8558-ff831457307e"
      },
      "source": [
        "r[r > 30]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([31, 32, 33, 34, 35])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDe0BiuEXKdY",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Here we are assigning all values in the array that are greater than 30 to the value of 30."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7hjhbHqMXKdY",
        "colab_type": "code",
        "colab": {},
        "outputId": "e84f40aa-7386-4bd6-d7e8-ae07a0d8d95a"
      },
      "source": [
        "r[r > 30] = 30\n",
        "r"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4,  5],\n",
              "       [ 6,  7,  8,  9, 10, 11],\n",
              "       [12, 13, 14, 15, 16, 17],\n",
              "       [18, 19, 20, 21, 22, 23],\n",
              "       [24, 25, 26, 27, 28, 29],\n",
              "       [30, 30, 30, 30, 30, 30]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YoB2p0LSXKda",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "## Copying Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sGFLZLqKXKdb",
        "colab_type": "text"
      },
      "source": [
        "Be careful with copying and modifying arrays in NumPy!\n",
        "\n",
        "\n",
        "`r2` is a slice of `r`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ScUDrNVhXKdb",
        "colab_type": "code",
        "colab": {},
        "outputId": "04f76e05-78f6-4a51-9498-022e9cb86d11"
      },
      "source": [
        "r2 = r[:3,:3]\n",
        "r2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2],\n",
              "       [ 6,  7,  8],\n",
              "       [12, 13, 14]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IS0cU-SwXKdi",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Set this slice's values to zero ([:] selects the entire array)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMV4yNPLXKdm",
        "colab_type": "code",
        "colab": {},
        "outputId": "d4bfba5e-b111-46d9-9859-eedff6603eea"
      },
      "source": [
        "r2[:] = 0\n",
        "r2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 0],\n",
              "       [0, 0, 0],\n",
              "       [0, 0, 0]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 126
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yw1xzA59XKdo",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "`r` has also been changed!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bCf_lzy_XKdp",
        "colab_type": "code",
        "colab": {},
        "outputId": "e7b03394-4ea0-4cbf-b8cb-26a19523faff"
      },
      "source": [
        "r"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  0,  0,  3,  4,  5],\n",
              "       [ 0,  0,  0,  9, 10, 11],\n",
              "       [ 0,  0,  0, 15, 16, 17],\n",
              "       [18, 19, 20, 21, 22, 23],\n",
              "       [24, 25, 26, 27, 28, 29],\n",
              "       [30, 30, 30, 30, 30, 30]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lYgDIGmlXKdt",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "To avoid this, use `r.copy` to create a copy that will not affect the original array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hkATV64FXKdu",
        "colab_type": "code",
        "colab": {},
        "outputId": "9ad6159f-fbc0-426c-8681-6f2184edb901"
      },
      "source": [
        "r_copy = r.copy()\n",
        "r_copy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  0,  0,  3,  4,  5],\n",
              "       [ 0,  0,  0,  9, 10, 11],\n",
              "       [ 0,  0,  0, 15, 16, 17],\n",
              "       [18, 19, 20, 21, 22, 23],\n",
              "       [24, 25, 26, 27, 28, 29],\n",
              "       [30, 30, 30, 30, 30, 30]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 128
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QolBTQTnXKdx",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Now when r_copy is modified, r will not be changed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZAihs7yMXKdy",
        "colab_type": "code",
        "colab": {},
        "outputId": "9bdd094a-6e86-403c-e988-90bfa46b30d8"
      },
      "source": [
        "r_copy[:] = 10\n",
        "print(r_copy, '\\n')\n",
        "print(r)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[10 10 10 10 10 10]\n",
            " [10 10 10 10 10 10]\n",
            " [10 10 10 10 10 10]\n",
            " [10 10 10 10 10 10]\n",
            " [10 10 10 10 10 10]\n",
            " [10 10 10 10 10 10]] \n",
            "\n",
            "[[ 0  0  0  3  4  5]\n",
            " [ 0  0  0  9 10 11]\n",
            " [ 0  0  0 15 16 17]\n",
            " [18 19 20 21 22 23]\n",
            " [24 25 26 27 28 29]\n",
            " [30 30 30 30 30 30]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dv9pWoPKXKdz",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "### Iterating Over Arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VHpN_YjcXKd1",
        "colab_type": "text"
      },
      "source": [
        "Let's create a new 4 by 3 array of random numbers 0-9."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9l8CAC-dXKd1",
        "colab_type": "code",
        "colab": {},
        "outputId": "8ecbd458-ecb0-42bc-980e-68f224d3e685"
      },
      "source": [
        "test = np.random.randint(0, 10, (4,3))\n",
        "test"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 1, 5],\n",
              "       [1, 8, 6],\n",
              "       [2, 7, 1],\n",
              "       [6, 8, 5]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 130
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nGN9NAJnXKd3",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Iterate by row:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WFO9lVXHXKd3",
        "colab_type": "code",
        "colab": {},
        "outputId": "92b14aff-ac1b-4546-c550-7b481d15109b"
      },
      "source": [
        "for row in test:\n",
        "    print(row)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2 1 5]\n",
            "[1 8 6]\n",
            "[2 7 1]\n",
            "[6 8 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_UiX1C-ZXKd8",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Iterate by index:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PxqAssrhXKd8",
        "colab_type": "code",
        "colab": {},
        "outputId": "520783b0-ed57-41b0-edaf-6f6770971cca"
      },
      "source": [
        "for i in range(len(test)):\n",
        "    print(test[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2 1 5]\n",
            "[1 8 6]\n",
            "[2 7 1]\n",
            "[6 8 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9YEfaFweXKd_",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Iterate by row and index:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b1VWZqYzXKd_",
        "colab_type": "code",
        "colab": {},
        "outputId": "43f4f9a9-d488-4059-d079-a8e5c9307b83"
      },
      "source": [
        "for i, row in enumerate(test):\n",
        "    print('row', i, 'is', row)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "row 0 is [2 1 5]\n",
            "row 1 is [1 8 6]\n",
            "row 2 is [2 7 1]\n",
            "row 3 is [6 8 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2WSaJLAyXKeB",
        "colab_type": "text"
      },
      "source": [
        "<br>\n",
        "Use `zip` to iterate over multiple iterables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ipkm5WAzXKeB",
        "colab_type": "code",
        "colab": {},
        "outputId": "63294192-142d-4735-f602-364ef33f5ee9"
      },
      "source": [
        "test2 = test**2\n",
        "test2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 4,  1, 25],\n",
              "       [ 1, 64, 36],\n",
              "       [ 4, 49,  1],\n",
              "       [36, 64, 25]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 134
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8eZSMIWAXKeF",
        "colab_type": "code",
        "colab": {},
        "outputId": "c202e343-2586-4543-ef4e-0f18b77db997"
      },
      "source": [
        "for i, j in zip(test, test2):\n",
        "    print(i,'+',j,'=',i+j)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2 1 5] + [ 4  1 25] = [ 6  2 30]\n",
            "[1 8 6] + [ 1 64 36] = [ 2 72 42]\n",
            "[2 7 1] + [ 4 49  1] = [ 6 56  2]\n",
            "[6 8 5] + [36 64 25] = [42 72 30]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vkcvzCnqXKeK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}