Python_guide.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hCNWKmR8MzA4"
      },
      "source": [
        "# Python walk-through\n",
        "\n",
        "This notebook will just go through the basic topics in order:\n",
        "\n",
        "\n",
        "###Data types\n",
        "    * Numbers\n",
        "    * Strings\n",
        "    * Printing\n",
        "    * Lists\n",
        "    * Dictionaries\n",
        "    * Booleans\n",
        "    * Tuples \n",
        "    * Sets\n",
        "\n",
        "###General\n",
        "    * Comparison Operators\n",
        "    * if, elif, else Statements\n",
        "    * for Loops\n",
        "    * while Loops\n",
        "    * range()\n",
        "    * list comprehension\n",
        "    * functions\n",
        "    * lambda expressions\n",
        "    * map and filter\n",
        "    * methods\n",
        "    * Error handling\n",
        "\n",
        "\n",
        "### Numpy\n",
        "    * Built in methods\n",
        "    * Attributes\n",
        "    * Indexing\n",
        "    * Selection\n",
        "    * Broadcasting\n",
        "    * 2D-arrays\n",
        "    * Slicing\n",
        "    * Selection\n",
        "    * Arithmetic operations\n",
        "    * Universal functions\n",
        "\n",
        "* Object oriented programming\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2HJZcFqMzBA"
      },
      "source": [
        "## Data types\n",
        "\n",
        "### Numbers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Raide1eMzBB",
        "outputId": "d6ea440f-076e-44ea-9d9a-4fcbc69c94ac"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 + 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "p8LCBJJnMzBE",
        "outputId": "fff51637-b99a-4aa0-cc52-127e1d68c642"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 * 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w5MN13HtMzBF",
        "outputId": "0795709a-90bb-45a0-c1d4-0a7c8c62572d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.5"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 / 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D2PNR14UMzBG",
        "outputId": "c6881dff-deda-4d99-fd43-83fe0d75003b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "2 ** 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "86b7NVwAMzBH",
        "outputId": "360dd019-160b-408d-a925-16d74a0bbdd2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "4 % 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yo1V44YCMzBJ",
        "outputId": "388a78db-2ab7-4717-de9e-ea0a5ffa4d3f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "5 % 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SWUo9PuoMzBK",
        "outputId": "495b3a1d-eac4-4a26-de7e-82f9e96240ad"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "50"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(2 + 3) * (5 + 5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3DwEhgiVMzBL"
      },
      "source": [
        "### Variable Assignment"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "mJTxFsh_MzBM"
      },
      "outputs": [],
      "source": [
        "# Can not start with number or special characters\n",
        "name_of_var = 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "grHr76_jMzBM"
      },
      "outputs": [],
      "source": [
        "x = 2\n",
        "y = 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "TMTKNWifMzBN"
      },
      "outputs": [],
      "source": [
        "z = x + y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B65B4dksMzBN",
        "outputId": "2de46542-6ab2-4a5c-9b54-2c77dc800ed8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "z"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9wtxrvdlMzBO"
      },
      "source": [
        "### Strings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1vA9vSbsMzBO",
        "outputId": "3555df1e-2968-4a81-d442-756a5ab74d2e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'single quotes'"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "'single quotes'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "AuPQHAzZMzBP",
        "outputId": "cffb2d6f-3adb-4135-b0ed-bac9cdb5eaaa"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'double quotes'"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"double quotes\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "sRyG-pElMzBP",
        "outputId": "08227231-64c6-43d2-b08f-affacfb4d3de"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "\" wrap lot's of other quotes\""
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\" wrap lot's of other quotes\"\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LwzdirJJMzBQ"
      },
      "source": [
        "### Printing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "collapsed": true,
        "id": "3-LtFtXeMzBQ"
      },
      "outputs": [],
      "source": [
        "x = 'hello'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "_-Av5FtqMzBR",
        "outputId": "8baed049-ee94-43ac-ba1e-e8436b05800d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'hello'"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "glF4F7IfMzBR",
        "outputId": "26427621-a8d2-4d09-8f63-8c20be0bb233"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hello\n"
          ]
        }
      ],
      "source": [
        "print(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "collapsed": true,
        "id": "A8XUhI_DMzBR"
      },
      "outputs": [],
      "source": [
        "num = 12\n",
        "name = 'Sam'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uEElWLs_MzBS",
        "outputId": "c3f00ec6-7191-4ecd-8a76-efdbe5daff35"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12 this is my number\n"
          ]
        }
      ],
      "source": [
        "# print('My number is: {one}, and my name is: {two}'.format(one=num,two=name))\n",
        "print(\"{var} this is my number\".format(var = num))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HdiPACuZMzBT",
        "outputId": "dc5b4098-92cd-4951-f29b-a3fc347baa61"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "My number is: 14, and my name is: Sam\n"
          ]
        }
      ],
      "source": [
        "num = 14\n",
        "print('My number is: {}, and my name is: {}'.format(num,name))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gGO0RBRCMzBT"
      },
      "source": [
        "### Lists"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UoCsR5HdMzBT",
        "outputId": "e27ddaf4-ca67-436b-a002-70ed63ff4064"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 2, 3]"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "[1,2,3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6bETqIHRMzBU",
        "outputId": "f1acc42d-75cd-457a-e737-7a1c4465d6c4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['hi', 1, [1, 2]]"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "[ 'hi' , 1 , [1,2] ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "928F_ygiMzBU"
      },
      "outputs": [],
      "source": [
        "my_list = ['a','b','c']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "s8gwzHWtMzBU"
      },
      "outputs": [],
      "source": [
        "my_list.append('d')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-1m_7NqFMzBV",
        "outputId": "4b6299ee-f5bf-4f8e-f6ba-b5e34ac024b2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['a', 'b', 'c', 'd']"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ydi10r2cMzBV",
        "outputId": "845d4970-710f-4b73-c0a8-698c41a19519"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'a'"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ahJh5NytMzBV",
        "outputId": "65abaebf-c67f-4867-f2fc-92fea68e9412"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'b'"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list[1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nxlUBfQjMzBV",
        "outputId": "a4c8d3a5-74b0-4563-8367-c293d3ff820e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['b', 'c', 'd']"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list[ 1 :  ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fnLbrv9qMzBW",
        "outputId": "f8d977d3-f249-486d-9722-39b5e9f494f4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['a']"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list[ : 1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "3jsomaTEMzBW"
      },
      "outputs": [],
      "source": [
        "my_list[0] = 'NEW'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A-65W4B4MzBW",
        "outputId": "781dab63-07d1-4284-e97e-636dff6be3ea"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['NEW', 'b', 'c', 'd']"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "CRnTenJ9MzBX"
      },
      "outputs": [],
      "source": [
        "nest = [1,2,3,[4,5,['target']]]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ADuJbxTpMzBX",
        "outputId": "84594434-8413-42cc-e97b-c1c9128a5cac"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[4, 5, ['target']]"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "nest[3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k8jBXuJPMzBX",
        "outputId": "07638884-2940-48d1-ea0e-7e278ad684c2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['target']"
            ]
          },
          "execution_count": 101,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "nest[3][2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "73Bnf0opMzBY",
        "outputId": "f9b4bb58-bfda-4ae6-9341-a86ea206ae33"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'target'"
            ]
          },
          "execution_count": 102,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "nest[3][2][0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MbG65ABMzBY"
      },
      "source": [
        "### Dictionaries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "collapsed": true,
        "id": "e2fVVkBfMzBZ"
      },
      "outputs": [],
      "source": [
        "d = { 'key1':'item1' , 'key2':'item2' }"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K-rEbyhJMzBZ",
        "outputId": "cc2c7974-8d8d-4069-f055-9e9560e320a1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'key1': 'item1', 'key2': 'item2'}"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "0uhRWvDUMzBZ",
        "outputId": "e46784db-cd16-4dec-d80d-cb4237ce1b97"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'item1'"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d['key1']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "aVC5fL4ayr7d"
      },
      "outputs": [],
      "source": [
        "# The values in dictionary items can be of any data type\n",
        "dict_ = {\n",
        "  \"brand\": \"Ford\" ,                    # String\n",
        "  \"electric\": False,                  # Boolean\n",
        "  \"year\": 1964,                       # Int\n",
        "  \"colors\": [\"red\", \"white\", \"blue\"]  # List  \n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e_SeIBtYP-P_",
        "outputId": "678c1932-a96b-4846-913d-6f67418c3b6a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'brand': 'Ford',\n",
              " 'electric': False,\n",
              " 'year': 1964,\n",
              " 'colors': ['red', 'white', 'blue']}"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "dict_"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2s63LbT5zCUd",
        "outputId": "0fd6c616-ec8d-4378-f0d3-1813e4298727"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'int'>\n"
          ]
        }
      ],
      "source": [
        "print(type(dict_[\"year\"]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eF8n8yHaMzBa"
      },
      "source": [
        "### Booleans"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lNmHK3LDMzBa",
        "outputId": "15920277-6a3d-4477-c57b-558ea6f14c66"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kcLcT2tTMzBa",
        "outputId": "bdebf763-2449-44c3-ad7d-06c957521eab"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 41,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mFYDT7a-MzBb"
      },
      "source": [
        "### Tuples "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "collapsed": true,
        "id": "MZ2TZnZaMzBb"
      },
      "outputs": [],
      "source": [
        "t = (1,2,3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BiYDc89mMzBb",
        "outputId": "540f3f13-9afa-4f54-dbbf-c6c4332850f5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "t[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "dKxygCdKMzBb",
        "outputId": "7dddc809-c215-4e03-85af-469162549631"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "'tuple' object does not support item assignment",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "Input \u001b[1;32mIn [17]\u001b[0m, in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[0m t[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mNEW\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
            "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ],
      "source": [
        "t[0] = 'NEW'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "msmiPgUDMzBc"
      },
      "source": [
        "### Sets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yD9XcecGMzBc",
        "outputId": "7b8e3c6b-d119-4c1f-f724-a12dae2bdd97"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 3}"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "{1,2,3}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j4oBU1pQMzBc",
        "outputId": "611ecbcb-1e1b-421b-9bf7-466845f316f7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 3}"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "{1,2,3,1,2,1,2,3,3,3,3,2,2,2,1,1,2}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MKXWb6eHLRig",
        "outputId": "20954c38-2a96-4463-bbe4-0f099b6c419a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 3}"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "s = set([1,1,1,2,3,3,3,3,3])\n",
        "s"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P8wyEk6OLazO",
        "outputId": "daa798cc-e5aa-436b-a525-4c45e831a189"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 3, 4}"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "s.add(4)\n",
        "s"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g7odMsCnLdhH",
        "outputId": "4aafa11b-5ac7-47ce-822e-999ed2bf322b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{1, 2, 3, 4}"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "s.add(4)\n",
        "# It wont add another 4 \n",
        "s"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grPyNlBnMzBc"
      },
      "source": [
        "## Comparison Operators"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "16FZfeOsMzBd",
        "outputId": "47818d01-27a5-4038-a85b-1d944957ad51"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 > 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HGUryzNLMzBd",
        "outputId": "8d66c286-1011-4402-9965-9e5d1127bf19"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 < 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ScMArxscMzBd",
        "outputId": "23ef47c1-ab2c-476c-9713-eb21c8330f75"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 49,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 >= 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6NqB_EmVMzBe",
        "outputId": "870489b3-a555-4eb9-dbcc-927ac146196d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 50,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 <= 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X-jXhtebMzBe",
        "outputId": "efb2af39-4585-45e8-e8dc-915cfea6f0e0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1 == 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "id": "5i0443aJLopn",
        "outputId": "74c79657-a7f3-48ab-af12-b3bb3d01af8a"
      },
      "outputs": [
        {
          "ename": "SyntaxError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-53-c23ea3aece4a>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    1 = 1\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to literal\n"
          ]
        }
      ],
      "source": [
        "# It will give you error\n",
        "# Coz here you are doing a variable assigment\n",
        "1 = 1 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IB42Cq_rMzBe",
        "outputId": "d1007e80-5def-4158-a94c-2a25d7518625"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "'hi' == 'bye'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2fNO3LlQMzBf"
      },
      "source": [
        "## Logic Operators"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DBIZs1TNziJm"
      },
      "outputs": [],
      "source": [
        "# T and T -> T  # T or T -> T\n",
        "# T and F -> F  # T or F -> T\n",
        "# F and T -> F  # F or T -> T\n",
        "# F and F -> F  # F or F -> F"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rPvGSmpxMzBf",
        "outputId": "180a6d31-5c40-4e49-d115-2b5c898eccab"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(1 > 2) and (2 < 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z8pGCrhtMzBf",
        "outputId": "7262ba0e-57d2-4b2d-a9ee-29b7eeeb70f2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(1 > 2) or (2 < 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mGYQ6_-PMzBf",
        "outputId": "b9677ec3-a8f0-4527-c8a7-40f0d33ab88c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(1 == 2) or (2 == 3) or (4 == 4)\n",
        "# F or F \n",
        "# F \n",
        "# F or T\n",
        "# T\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P1vNSet5MzBg"
      },
      "source": [
        "## if,elif, else Statements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kEVsk0p2MzBg",
        "outputId": "162b21ab-ee11-4665-cc90-378cd95d23cd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Yep!\n"
          ]
        }
      ],
      "source": [
        "if (1 < 2):\n",
        "  print('Yep!')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nBQ84f91MzBg"
      },
      "outputs": [],
      "source": [
        "if (1 > 2):\n",
        "    print('yep!')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oLdVq_YHMzBg",
        "outputId": "ee29b190-e731-45bc-9bb5-daa6189a3792"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "last\n"
          ]
        }
      ],
      "source": [
        "if (1 > 2):\n",
        "    print('first')\n",
        "else:\n",
        "    print('last')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kdHXqeGmMzBo",
        "outputId": "3b8f909f-c6a6-4f2d-b3b8-f92d110d7ce1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "last\n"
          ]
        }
      ],
      "source": [
        "if 1 > 2:\n",
        "    print('first')\n",
        "else:\n",
        "    print('last')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hMSnIrbpMzBp",
        "outputId": "19b9c76a-bfd7-4508-bd3c-b84585244ece"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "middle\n",
            "DOne\n"
          ]
        }
      ],
      "source": [
        "if 1 == 2:\n",
        "    print('first')\n",
        "elif 3 == 3:\n",
        "    print('middle')\n",
        "elif 4==3:\n",
        "  print(\"four\")\n",
        "else:\n",
        "    print('Last')\n",
        "\n",
        "\n",
        "print('DOne')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yv88aEzhMzBp"
      },
      "source": [
        "## for Loops"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uLEnEtsnMzBp"
      },
      "outputs": [],
      "source": [
        "seq = [1,2,3,4,5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8HgEDDb7MzBq",
        "outputId": "580a941a-67d3-4983-a7da-98b9212aa28b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "for item in seq:\n",
        "    print(item)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7WZwMswYMzBq",
        "outputId": "573afaf9-899d-4061-8b74-0329c89e7541"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Yep\n",
            "Yep\n",
            "Yep\n",
            "Yep\n",
            "Yep\n"
          ]
        }
      ],
      "source": [
        "for item in seq:\n",
        "    print('Yep')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KF55MV7FMzBq",
        "outputId": "73323cb6-db88-4cba-cf71-f73a5e3a6f51"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n"
          ]
        }
      ],
      "source": [
        "for jelly in seq:\n",
        "    print(jelly+jelly)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E4yI7jLuMzBr"
      },
      "source": [
        "## while Loops"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S-FPHcfRMzBr",
        "outputId": "f86ad142-3485-4c2b-b8a0-a8d98a0c5d0f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "i is: 1\n",
            "i is: 2\n",
            "i is: 3\n",
            "i is: 4\n",
            "i is: 5\n"
          ]
        }
      ],
      "source": [
        "i = 1\n",
        "while (i <= 5):\n",
        "    print('i is: {}'.format(i))\n",
        "    i = i+1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hI_N68yqMzBr"
      },
      "source": [
        "## range()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TL6nLEbMMzBr",
        "outputId": "2dad7095-93b6-48a9-e463-0c73e03d8768"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "range(0, 5)"
            ]
          },
          "execution_count": 67,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "range(5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5QhshTzTMzBs",
        "outputId": "fb41c8c1-b2e7-47c1-8bc4-8aa2e43d82ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "for i in range(5):\n",
        "    print(i)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XCMe40uYMzBs",
        "outputId": "0d1019a8-2e5c-46a9-9fe1-09a920cd1115"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4]"
            ]
          },
          "execution_count": 69,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list(range(5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YaBgpSYlMzBs"
      },
      "source": [
        "## list comprehension"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "IzDsjXocMzBs"
      },
      "outputs": [],
      "source": [
        "x = [1,2,3,4]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FwwYiYQFMzBt",
        "outputId": "7b173b93-3ce1-4ae4-a356-f1eff44eced9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 4, 9, 16]\n"
          ]
        }
      ],
      "source": [
        "out = []\n",
        "for item in x:\n",
        "    out.append(item**2)\n",
        "print(out)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_ugpHhmAMzBt",
        "outputId": "1f93dd68-2a12-4f72-c4ad-5ea00cc456cc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 8, 27, 64]"
            ]
          },
          "execution_count": 74,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "store = [item**3 for item in x]\n",
        "store"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HyxbSTNWMzBt"
      },
      "source": [
        "## functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "collapsed": true,
        "id": "G82hKB7GMzBt"
      },
      "outputs": [],
      "source": [
        "def my_func(param1='default'):\n",
        "    \"\"\"\n",
        "    Docstring goes here.\n",
        "\n",
        "    Add numbers \n",
        "      \n",
        "    \"\"\"\n",
        "    print(param1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iQbNT28yMzBu",
        "outputId": "2c876775-4b50-4b1f-d7db-ed2683f65f23"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<function __main__.my_func(param1='default')>"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_func"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uFLVU_n5MzBu",
        "outputId": "aab0bed1-7211-4a50-8854-0a3755064928"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "default\n"
          ]
        }
      ],
      "source": [
        "my_func()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tt_0Uq2nMzBu",
        "outputId": "eea40aa6-e3b8-47ac-c8f6-e5ee8bd6cacc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2+6\n",
            "8\n"
          ]
        }
      ],
      "source": [
        "my_func(\"2+6\")\n",
        "my_func(2+6)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "BMSXtU4iMzBu",
        "outputId": "f7f9a8e9-50d5-4ded-c7b4-2807f19fdfe0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "new param\n"
          ]
        }
      ],
      "source": [
        "my_func(param1='new param')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "PiSmkjpiMzBv"
      },
      "outputs": [],
      "source": [
        "def square(x):\n",
        "    return x**2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "SeTljqO5MzBv"
      },
      "outputs": [],
      "source": [
        "out = square(34)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BbzvPUIhMzBv",
        "outputId": "a75ab8a8-7e99-4e4e-ed75-e5e9090daaa8",
        "scrolled": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1156\n"
          ]
        }
      ],
      "source": [
        "print(out)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vehYCw-OMzBv"
      },
      "source": [
        "## lambda expressions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "1grx4VyhMzBw"
      },
      "outputs": [],
      "source": [
        "def times2(var):\n",
        "    return var*2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-0x8g4rJMzBw",
        "outputId": "9e46bb80-908e-4332-e41a-ad8dc6b00b37"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "times2(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tmokRZwH8A-J"
      },
      "outputs": [],
      "source": [
        "def times2(var):return var*2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rq5gcVWyMzBw",
        "outputId": "fe36c3c3-d36e-4c0d-c3f9-568433904dfe"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<function __main__.<lambda>>"
            ]
          },
          "execution_count": 85,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "lambda var: var*2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x8czzRgVcIc5",
        "outputId": "3940c62b-1357-47fc-cb45-eabe90696d33"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "execution_count": 86,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "func = lambda var: var*3\n",
        "func(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QctnNayo30of",
        "outputId": "2cc0c6e4-645c-46da-d0cc-8ef981b06e54"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "15\n"
          ]
        }
      ],
      "source": [
        "x = lambda a : a + 10\n",
        "print(x(5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DqAIjSfJ327_",
        "outputId": "f5943e0c-0618-40f5-db4f-b9ac8af2bea0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "30\n"
          ]
        }
      ],
      "source": [
        "x = lambda a , b : a * b\n",
        "print(x(5, 6))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Pt7LcbxMzBw"
      },
      "source": [
        "## map and filter"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VC-wNFC_7P-h",
        "outputId": "8232dce4-f136-4676-f122-99934d65dda1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "execution_count": 89,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def times2(var):\n",
        "    return var*2\n",
        "\n",
        "times2(4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "kxcPmWZpMzBx"
      },
      "outputs": [],
      "source": [
        "seq = [1,2,3,4,5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "knWquEWLMzBx",
        "outputId": "79d6f3c7-5398-4512-8c77-a2717537faf4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<map at 0x7f7db5c95290>"
            ]
          },
          "execution_count": 90,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Apply times2 func on each element\n",
        "map( times2  , seq)\n",
        "# Returns map at a particular place at memory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yIEch0lCMzBy",
        "outputId": "40b071ab-c4f8-4646-e462-c760dae05589"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, 4, 6, 8, 10]"
            ]
          },
          "execution_count": 91,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Returns the list \n",
        "list(map(times2,seq))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WV-c7FeLMzBy",
        "outputId": "75e766c6-2d74-48dd-d4ee-5cf3d77ca897"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[3, 6, 9, 12, 15]"
            ]
          },
          "execution_count": 92,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list(map(lambda var: var*3 ,seq))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bCEHO_k0MzBy",
        "outputId": "2002c30d-eed3-430e-b23e-8dfe7cfb4007"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<filter at 0x7f7db5c66d10>"
            ]
          },
          "execution_count": 93,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Filters out or returns boolean value\n",
        "filter(lambda item: item%2 == 0, seq)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HGq3Z6F2MzBz",
        "outputId": "1276c308-4099-4d9c-d0b3-3eba44918e1d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, 4]"
            ]
          },
          "execution_count": 94,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list(filter(lambda item: item%2 == 0,seq))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c9Vk0RMTMzBz"
      },
      "source": [
        "## methods"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "collapsed": true,
        "id": "I3_5LYPcMzBz"
      },
      "outputs": [],
      "source": [
        "st = 'hello mY  name is Sam'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "GRQ4Ns25MzBz",
        "outputId": "bfaccf37-ff91-420f-e1e0-a3ef286550a5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'hello my  name is sam'"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "st.lower()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "i57OKEQFMzB0",
        "outputId": "9704a7ff-9c19-41ef-9843-4ace61142f3b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'HELLO MY  NAME IS SAM'"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "st.upper()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pevrNFZnMzB1",
        "outputId": "cb51e6fa-7858-4297-b513-9fb9113fe66f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['hello', 'mY', 'name', 'is', 'Sam']"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "st.split()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "collapsed": true,
        "id": "d9Y-IHclMzB1"
      },
      "outputs": [],
      "source": [
        "tweet = 'Go Sports! #Sports'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "X5a7IDZNMzB1",
        "outputId": "100564a8-d2bd-4647-c8d1-c2fe171f8a98"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['Go Sports! ', 'Sports']"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tweet.split('#')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "PY-OvnMmMzB2",
        "outputId": "ee6e2b12-2e41-4226-cd60-e1e7af2d035e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'S'"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tweet.split('#')[1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ANLBerDzMzB2",
        "outputId": "478730c5-6d3b-427e-c209-90e2e2517a20"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'key1': 'item1', 'key2': 'item2'}"
            ]
          },
          "execution_count": 103,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IvrIiMFcMzB2",
        "outputId": "f5f882b0-172d-47ae-e05b-b22f0b169d75"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'd' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "Input \u001b[1;32mIn [22]\u001b[0m, in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43md\u001b[49m\u001b[38;5;241m.\u001b[39mkeys()\n",
            "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined"
          ]
        }
      ],
      "source": [
        "d.keys()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_sqeVQgqMzB3",
        "outputId": "96e23dba-73d5-45ea-b6c0-0793cb28ab80"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'd' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "Input \u001b[1;32mIn [23]\u001b[0m, in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43md\u001b[49m\u001b[38;5;241m.\u001b[39mitems()\n",
            "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined"
          ]
        }
      ],
      "source": [
        "d.items()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "rcbP3o6ZMzB3"
      },
      "outputs": [],
      "source": [
        "lst = [1,2,3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z0-VAz22MzB3",
        "outputId": "6b9e4c46-9c8f-412c-bc14-3b3786e93663"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 108,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "lst.pop()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "fZTFz_1NMzB4"
      },
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'lst' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "Input \u001b[1;32mIn [24]\u001b[0m, in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mlst\u001b[49m\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;241m5\u001b[39m)\n",
            "\u001b[1;31mNameError\u001b[0m: name 'lst' is not defined"
          ]
        }
      ],
      "source": [
        "lst.append(5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SSBBD5wmJEyn",
        "outputId": "af7f0443-a79a-4985-81d7-b964db2bafa7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 5]"
            ]
          },
          "execution_count": 110,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "lst"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-P3iW8jMzB4",
        "outputId": "c1b1dc01-460d-45bf-9b0c-50ca9ca10019"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 111,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "'x' in [1,2,3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7YGFYUbdMzB4",
        "outputId": "900c9879-dee9-4007-aa9a-ee493ee35c7b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 112,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "'x' in ['x','y','z']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsiXgqaAMzB5"
      },
      "source": [
        "# Error Handling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3xuSf-fLMzB5",
        "outputId": "aa9b5c1a-1524-4c35-92cd-88c340ecf26c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1.8e-64"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var=10\n",
        "answer = int(input(\"Enter Number: \"))\n",
        "var/answer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GNPkAP10MzB6",
        "outputId": "d33faac4-4af5-4cdb-ed7b-613f5eeb06f7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Caught any exception dont pass a string\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# code asks user for number and divides 10 by it\n",
        "# enter '0' to trigger exception\n",
        "# enter any string to check for exception\n",
        "try:\n",
        "    var=10\n",
        "    answer = int(input(\"Enter Number: \"))\n",
        "    var/answer\n",
        "except ZeroDivisionError as e:\n",
        "    print(e)\n",
        "except ValueError:\n",
        "    print(\"Caught any exception dont pass a string\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W1J_bcOcMzB8",
        "outputId": "aa8cf6d5-693f-4ac0-d08d-521bf7484165"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter Number: 45\n",
            "Exit code\n"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    var=10\n",
        "    answer = int(input(\"Enter Number: \"))\n",
        "    var/answer\n",
        "except ZeroDivisionError as e:\n",
        "    print(e)\n",
        "except ValueError:\n",
        "    print(\"Caught any exception\")\n",
        "except:\n",
        "    pass\n",
        "\n",
        "    \n",
        "finally:\n",
        "    print(\"Exit code\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Bsrtc3OMzB9"
      },
      "source": [
        "# NumPy \n",
        "\n",
        "NumPy (or Numpy) is a Linear Algebra Library for Python, the reason it is so important for Data Science with Python is that almost all of the libraries in the PyData Ecosystem rely on NumPy as one of their main building blocks.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IOKc9i8sMzB9"
      },
      "source": [
        "## Install numpy "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4HIyvNNMzB9",
        "outputId": "357d6472-7967-4319-c57b-b7ed8367ae90"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (1.19.5)\n"
          ]
        }
      ],
      "source": [
        "# !pip install numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcKJ8vA6MzB-"
      },
      "source": [
        "## Using NumPy\n",
        "\n",
        "Once you've installed NumPy you can import it as a library:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KZG07uSCMzB-"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1lFDQK8MzB-"
      },
      "source": [
        "Numpy has many built-in functions and capabilities. We won't cover them all but instead we will focus on some of the most important aspects of Numpy: vectors,arrays,matrices, and number generation. Let's start by discussing arrays.\n",
        "\n",
        "# Numpy Arrays\n",
        "\n",
        "NumPy arrays are the main way we will use Numpy throughout the workshop. Numpy arrays essentially come in two flavors: vectors and matrices. Vectors are strictly 1-d arrays and matrices are 2-d (but you should note a matrix can still have only one row or one column).\n",
        "\n",
        "Let's begin our introduction by exploring how to create NumPy arrays.\n",
        "\n",
        "## Creating NumPy Arrays\n",
        "\n",
        "### From a Python List\n",
        "\n",
        "We can create an array by directly converting a list or list of lists:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z9bqrP5XMzB-",
        "outputId": "fadebdc0-4647-4f62-c4ac-4a1a83202257"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 2, 3]"
            ]
          },
          "execution_count": 123,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_list = [1,2,3]\n",
        "my_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vS-tUfTjMzB_",
        "outputId": "02871d54-d2eb-4dbe-d3ae-61a1843a0847"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "execution_count": 124,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ar = np.array(my_list)\n",
        "ar \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e9QSlg3Wxcjy",
        "outputId": "53acd495-f907-466f-e541-bb2a284aadb1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1, 2, 3]"
            ]
          },
          "execution_count": 125,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Convert back array in to list\n",
        "list(ar)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v0WJmLkGMzB_",
        "outputId": "27c5a770-11cb-465d-d6f5-b07d761276d4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "execution_count": 126,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "my_matrix = [ [1,2,3] , [4,5,6] , [7,8,9] ]\n",
        "arr = np.array(my_matrix)\n",
        "arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K-cV7WncxqJv",
        "outputId": "6d347614-f096-454b-97b4-be33d6d192c2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]"
            ]
          },
          "execution_count": 127,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Convert 2d array into list\n",
        "list(arr)\n",
        "# It is storing a list of arrays"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6DmMzeENyEHg",
        "outputId": "aa4b19b3-b444-44f0-9a91-b4f5908c26a2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
            ]
          },
          "execution_count": 128,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Converts 2d array to list\n",
        "arr.tolist()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BfKIJMq7MzB_",
        "outputId": "a3034860-1bb3-4be8-9ec6-015363b7c397"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "execution_count": 129,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.array(my_matrix)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GI3wYdzbMzCA"
      },
      "source": [
        "## Built-in Methods\n",
        "\n",
        "There are lots of built-in ways to generate Arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jDIxTmT9MzCA"
      },
      "source": [
        "### arange\n",
        "\n",
        "Return evenly spaced values within a given interval."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wHuQG5IkMzCA",
        "outputId": "9c8b070b-8ee8-476c-e24a-77f0d76d083a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.arange(0,10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DhQFNNk-MzCA",
        "outputId": "ec01acf8-eb45-4426-95ac-f67b93e667ff"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0, 3, 6, 9])"
            ]
          },
          "execution_count": 131,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.arange(0,11,3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YVgr-TZsMzCB"
      },
      "source": [
        "### zeros and ones\n",
        "\n",
        "Generate arrays of zeros or ones"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hBLIksLVMzCB",
        "outputId": "1b7282f1-c654-4220-85cc-79adb338f26a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.,  0.,  0.])"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.zeros(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CluorO6KMzCB",
        "outputId": "ac6aa236-4354-4a59-a19c-1a74c0026b0d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0.,  0.,  0.,  0.,  0.],\n",
              "       [ 0.,  0.,  0.,  0.,  0.],\n",
              "       [ 0.,  0.,  0.,  0.,  0.],\n",
              "       [ 0.,  0.,  0.,  0.,  0.],\n",
              "       [ 0.,  0.,  0.,  0.,  0.]])"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.zeros((5,5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1fuNCcZSMzCB",
        "outputId": "d392034c-945c-4592-92c9-d0f3fa90c7f4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1.,  1.,  1.])"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.ones(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AQnSj7zkMzCC",
        "outputId": "11f4beee-7d46-4633-f4d2-ea3bf3645a1d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1.,  1.,  1.],\n",
              "       [ 1.,  1.,  1.],\n",
              "       [ 1.,  1.,  1.]])"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.ones((3,3))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JCzg9f5OMzCC"
      },
      "source": [
        "### linspace\n",
        "Return evenly spaced numbers over a specified interval."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t5KcATlSMzCC",
        "outputId": "49425afa-e7fe-4e64-dbd6-ac6087677d3d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.,  5., 10.])"
            ]
          },
          "execution_count": 132,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.linspace(0,10,3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gIrjhFIJMzCC",
        "outputId": "92e7cf06-b723-40ca-f8f6-59467eed4b34"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,\n",
              "        1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,\n",
              "        2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,\n",
              "        3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,\n",
              "        4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,\n",
              "        5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,\n",
              "        6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,\n",
              "        7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,\n",
              "        8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,\n",
              "        9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])"
            ]
          },
          "execution_count": 133,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.linspace(0,10,50)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8jb4Pl1MzCD"
      },
      "source": [
        "## eye\n",
        "\n",
        "Creates an identity matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ju9U1hv1MzCD",
        "outputId": "c678e2e7-0314-4e5d-ba41-5d29a13f7b7e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1.,  0.,  0.,  0.],\n",
              "       [ 0.,  1.,  0.,  0.],\n",
              "       [ 0.,  0.,  1.,  0.],\n",
              "       [ 0.,  0.,  0.,  1.]])"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.eye(4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wkD34NhOMzCE"
      },
      "source": [
        "## Random \n",
        "\n",
        "Numpy also has lots of ways to create random number arrays:\n",
        "\n",
        "### rand\n",
        "Create an array of the given shape and populate it with\n",
        "random samples from a uniform distribution\n",
        "over ``[0, 1)``."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "321ygfyGMzCE",
        "outputId": "11af9832-7875-4229-9dec-30bb103a5f0e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0.45346703, 0.1497983 , 0.87266952])"
            ]
          },
          "execution_count": 134,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.rand(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dbFGzcrJMzCF",
        "outputId": "bda97512-d689-423d-c721-841949c07a32"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0.42442332, 0.2524502 , 0.42153375, 0.42342204, 0.99055167],\n",
              "       [0.908554  , 0.87508428, 0.19406493, 0.92307498, 0.06234637],\n",
              "       [0.35323966, 0.05491062, 0.39163486, 0.57011386, 0.36450496],\n",
              "       [0.34669702, 0.91678722, 0.41248057, 0.37321225, 0.48298827],\n",
              "       [0.21634103, 0.90925935, 0.46150927, 0.55268504, 0.13477428]])"
            ]
          },
          "execution_count": 135,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.rand(5,5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xyn_guW0MzCF"
      },
      "source": [
        "### randn\n",
        "\n",
        "Return a sample (or samples) from the \"standard normal\" distribution. Unlike rand which is uniform:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wLkPHEqZMzCF",
        "outputId": "3455547f-d80a-406b-e94d-1c1de6eeb2ab"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([-0.16605779,  0.65824292, -0.35998725,  0.07601771, -0.34089485,\n",
              "        0.11430547])"
            ]
          },
          "execution_count": 136,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.randn(6)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-FooS9rKMzCG",
        "outputId": "09ed4a6d-8078-4a8e-87ad-14a5d9004283"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0.70154515,  0.22441999,  1.33563186,  0.82872577, -0.28247509],\n",
              "       [ 0.64489788,  0.61815094, -0.81693168, -0.30102424, -0.29030574],\n",
              "       [ 0.8695976 ,  0.413755  ,  2.20047208,  0.17955692, -0.82159344],\n",
              "       [ 0.59264235,  1.29869894, -1.18870241,  0.11590888, -0.09181687],\n",
              "       [-0.96924265, -1.62888685, -2.05787102, -0.29705576,  0.68915542]])"
            ]
          },
          "execution_count": 45,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.randn(5,5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4MQTfhm2MzCG"
      },
      "source": [
        "### randint\n",
        "Return random integers from `low` (inclusive) to `high` (exclusive)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YkuX6OC9MzCG",
        "outputId": "1b9d4ec2-3c15-490f-9d0d-e806047034e4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "94"
            ]
          },
          "execution_count": 137,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.randint(1,100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M7CjVnEfMzCG",
        "outputId": "f93aaaa0-a872-48dc-ad18-de369e2cc076"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([40, 77, 38, 92, 50, 22, 89, 12, 88, 92])"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.randint(1,100,10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3lgffWQUwpea",
        "outputId": "77e31666-9b5b-4655-e153-f5b13e0f3cce"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([24, 70, 33, 67,  4, 90, 68, 63, 68, 96])"
            ]
          },
          "execution_count": 138,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from numpy.random import randint \n",
        "randint(1,100,10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50hWEtl1MzCH"
      },
      "source": [
        "## Array Attributes and Methods\n",
        "\n",
        "Let's discuss some useful attributes and methods or an array:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "WBuK2fmgMzCH"
      },
      "outputs": [],
      "source": [
        "arr = np.arange(25)\n",
        "ranarr = np.random.randint(0,50,10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DWCp4A_QMzCH",
        "outputId": "cf1e5969-bff6-4a7d-d025-66c0f2b10442"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
              "       17, 18, 19, 20, 21, 22, 23, 24])"
            ]
          },
          "execution_count": 141,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-y-KPzZIMzCH",
        "outputId": "fa5d734a-9ecc-4a6f-be8f-5c3337fc04d3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([49,  9, 10, 26,  4, 34, 25, 13, 44, 40])"
            ]
          },
          "execution_count": 142,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ranarr"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XnsPCaA-MzCI"
      },
      "source": [
        "## Reshape\n",
        "Returns an array containing the same data with a new shape."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kPqNug66MzCI",
        "outputId": "d93a098f-949d-4521-b614-70bad751a1d9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8,  9],\n",
              "       [10, 11, 12, 13, 14],\n",
              "       [15, 16, 17, 18, 19],\n",
              "       [20, 21, 22, 23, 24]])"
            ]
          },
          "execution_count": 143,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr.reshape(5,5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8UyCgkYzMzCI"
      },
      "source": [
        "### max,min,argmax,argmin\n",
        "\n",
        "These are useful methods for finding max or min values. Or to find their index locations using argmin or argmax"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "duna40shMzCI",
        "outputId": "a54bd2b9-3a1f-4b7a-e717-79da89a031eb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([49,  9, 10, 26,  4, 34, 25, 13, 44, 40])"
            ]
          },
          "execution_count": 144,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ranarr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d7dL7E8yMzCJ",
        "outputId": "8d758e0e-fce4-4cf6-efec-0c9154fbb386"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "49"
            ]
          },
          "execution_count": 145,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ranarr.max()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3LaQiUkcMzCJ",
        "outputId": "5a2cd918-2be8-4383-f783-6c2cba9c5011"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 146,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Index of max element\n",
        "ranarr.argmax()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SFP-6W0QMzCJ",
        "outputId": "8a2e8354-b018-4db3-a116-0b98e9d6b44b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 147,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ranarr.min()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7fnQNxQ3MzCJ",
        "outputId": "6eb06262-4d50-4b86-b681-feafb874de55"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 148,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Index of min element\n",
        "ranarr.argmin()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wUgIcHB0MzCK"
      },
      "source": [
        "## Shape\n",
        "\n",
        "Shape is an attribute that arrays have (not a method):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1JRCrISxMzCK",
        "outputId": "62e4c94c-e002-444f-8be8-7df91e772372"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(25,)"
            ]
          },
          "execution_count": 150,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Vector\n",
        "arr.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zjgstdGqMzCL",
        "outputId": "39cba7dc-2bb2-4fd9-b578-8aa176f7e54f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,\n",
              "        16, 17, 18, 19, 20, 21, 22, 23, 24]])"
            ]
          },
          "execution_count": 151,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Notice the two sets of brackets\n",
        "arr.reshape(1,25)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y4FpI0tjMzCL",
        "outputId": "d904179b-9765-4a94-f61c-62b7ac5308a4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(1, 25)"
            ]
          },
          "execution_count": 152,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr.reshape(1,25).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3SDYV5nOMzCL",
        "outputId": "20df8ce0-24ea-42b7-ef36-0a23d3a8a873"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0],\n",
              "       [ 1],\n",
              "       [ 2],\n",
              "       [ 3],\n",
              "       [ 4],\n",
              "       [ 5],\n",
              "       [ 6],\n",
              "       [ 7],\n",
              "       [ 8],\n",
              "       [ 9],\n",
              "       [10],\n",
              "       [11],\n",
              "       [12],\n",
              "       [13],\n",
              "       [14],\n",
              "       [15],\n",
              "       [16],\n",
              "       [17],\n",
              "       [18],\n",
              "       [19],\n",
              "       [20],\n",
              "       [21],\n",
              "       [22],\n",
              "       [23],\n",
              "       [24]])"
            ]
          },
          "execution_count": 153,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr.reshape(25,1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZC82zen1MzCM",
        "outputId": "c4e7761b-ad7f-4b28-8970-12e3b37486ba"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(25, 1)"
            ]
          },
          "execution_count": 154,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr.reshape(25,1).shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zz_0umGqMzCM"
      },
      "source": [
        "### dtype\n",
        "\n",
        "You can also grab the data type of the object in the array:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zwHB5B7EMzCM",
        "outputId": "0d26fae7-65e2-41ff-dd43-0a10a070e970"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "execution_count": 155,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr.dtype"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sqdy4jUJMzCM"
      },
      "source": [
        "# NumPy Indexing and Selection\n",
        "\n",
        "Now we will discuss how to select elements or groups of elements from an array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "htm6ErjEMzCN"
      },
      "outputs": [],
      "source": [
        "#Creating sample array\n",
        "arr = np.arange(0,11)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w0ajXEZ9MzCN",
        "outputId": "0fa9a104-4111-482c-d049-ee57a2327616"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 157,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Show\n",
        "arr"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1F8PtmEKMzCN"
      },
      "source": [
        "## Bracket Indexing and Selection\n",
        "The simplest way to pick one or some elements of an array looks very similar to python lists:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ljXOuUdKMzCN",
        "outputId": "c10c58c3-9ad1-4862-d1a1-d0274dca8c7c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "execution_count": 158,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Get a value at an index\n",
        "arr[8]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QxXUs4cXMzCN",
        "outputId": "9e50185c-25c0-453d-a6fc-9199b5947d93"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "execution_count": 159,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Get values in a range\n",
        "arr[1:5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4_fIzlSNMzCO",
        "outputId": "fbea3afa-2551-4439-d10a-20e9023a5bd1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4])"
            ]
          },
          "execution_count": 160,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Get values in a range\n",
        "arr[0:5]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VCyo8fi_MzCO"
      },
      "source": [
        "## Broadcasting\n",
        "\n",
        "Numpy arrays differ from a normal Python list because of their ability to broadcast:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TV_hlwEmMzCO",
        "outputId": "3db89da2-aa01-4967-cd15-38d568b7ff9c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([100, 100, 100, 100, 100,   5,   6,   7,   8,   9,  10])"
            ]
          },
          "execution_count": 161,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Setting a value with index range (Broadcasting)\n",
        "arr[0:5]=100\n",
        "\n",
        "#Show\n",
        "arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y-BB-hvXMzCP",
        "outputId": "102b0f12-4451-4581-8ec9-a3f6a4b24712"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 162,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Reset array, we'll see why I had to reset in  a moment\n",
        "arr = np.arange(0,11)\n",
        "\n",
        "#Show\n",
        "arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Spqd_rJ5MzCP",
        "outputId": "a2882534-96a4-4fc9-c8cb-15de00c21707"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5])"
            ]
          },
          "execution_count": 163,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Important notes on Slices\n",
        "slice_of_arr = arr[0:6]\n",
        "\n",
        "#Show slice\n",
        "slice_of_arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3QkRohwyMzCP",
        "outputId": "eb651ade-381c-4f08-b629-54750230eadf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([99, 99, 99, 99, 99, 99])"
            ]
          },
          "execution_count": 164,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Change Slice\n",
        "slice_of_arr[:]=99\n",
        "\n",
        "#Show Slice again\n",
        "slice_of_arr"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4G-JTUCQMzCP"
      },
      "source": [
        "Now note the changes also occur in our original array!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lrkd00JWMzCQ",
        "outputId": "ae51471c-d976-414b-c182-712631834548"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([99, 99, 99, 99, 99, 99,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 165,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c8USAxIuMzCQ"
      },
      "source": [
        "Data is not copied, it's a view of the original array! This avoids memory problems!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SODBmpwxMzCQ",
        "outputId": "4a878f67-352e-4040-c0ce-b67ef92a3782"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([99, 99, 99, 99, 99, 99,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 166,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#To get a copy, need to be explicit\n",
        "arr_copy = arr.copy()\n",
        "\n",
        "arr_copy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-YllIwk8MzCR"
      },
      "source": [
        "## Indexing a 2D array (matrices)\n",
        "\n",
        "The general format is **arr_2d[row][col]** or **arr_2d[row,col]**. I recommend usually using the comma notation for clarity."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7x0MKnxwMzCS",
        "outputId": "3eadecb6-240e-4c6d-a79c-ad0513eb73cb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 5, 10, 15],\n",
              "       [20, 25, 30],\n",
              "       [35, 40, 45]])"
            ]
          },
          "execution_count": 167,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d = np.array(([5,10,15],[20,25,30],[35,40,45]))\n",
        "\n",
        "#Show\n",
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-s40Kjg0MzCS",
        "outputId": "f4ec897e-e35c-46c1-b696-484b366ec0fe"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([20, 25, 30])"
            ]
          },
          "execution_count": 168,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Indexing row\n",
        "arr_2d[1]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B0xgeIP6MzCS",
        "outputId": "614b2e05-2fce-480e-cc5b-330a823cce2a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "execution_count": 169,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Format is arr_2d[row][col] or arr_2d[row,col]\n",
        "\n",
        "# Getting individual element value\n",
        "arr_2d[1][0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aQKiy2hFMzCT",
        "outputId": "5d078540-5a07-4c7f-e71e-dfbac4cd8d7a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "execution_count": 170,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Getting individual element value\n",
        "arr_2d[1,0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZwnhtH3MMzCT",
        "outputId": "ffcabd97-93e3-4da1-ea21-0c10d9ed5ef8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[10, 15],\n",
              "       [25, 30]])"
            ]
          },
          "execution_count": 171,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 2D array slicing\n",
        "\n",
        "#Shape (2,2) from top right corner\n",
        "arr_2d[ :2 , 1: ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fx9nMcjFMzCT",
        "outputId": "8b32906a-4ab3-4ffe-bcc1-10b1cd6d8677"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([35, 40, 45])"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Shape bottom row\n",
        "arr_2d[2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "chalrDy-MzCU",
        "outputId": "744aa103-c546-495e-acb5-77f7e5bba58e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([35, 40, 45])"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Shape bottom row\n",
        "arr_2d[ 2 , : ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8L1Ms6D3MzCU"
      },
      "source": [
        "### Fancy Indexing\n",
        "\n",
        "Fancy indexing allows you to select entire rows or columns out of order,to show this, let's quickly build out a numpy array:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wY80JEwxMzCU"
      },
      "outputs": [],
      "source": [
        "#Set up matrix\n",
        "arr2d = np.zeros((10,10))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qFwfYvA4MzCU"
      },
      "outputs": [],
      "source": [
        "#Length of array\n",
        "arr_length = arr2d.shape[1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qGy-7PQDMzCV",
        "outputId": "29998b1a-d2c6-4db1-e29b-8c9922f62561"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
              "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
              "       [4., 4., 4., 4., 4., 4., 4., 4., 4., 4.],\n",
              "       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],\n",
              "       [6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n",
              "       [7., 7., 7., 7., 7., 7., 7., 7., 7., 7.],\n",
              "       [8., 8., 8., 8., 8., 8., 8., 8., 8., 8.],\n",
              "       [9., 9., 9., 9., 9., 9., 9., 9., 9., 9.]])"
            ]
          },
          "execution_count": 174,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Set up array\n",
        "\n",
        "for i in range(arr_length):\n",
        "    arr2d[i] = i\n",
        "    \n",
        "arr2d"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dNG73neKMzCV"
      },
      "source": [
        "Fancy indexing allows the following"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e9tjerW5MzCV",
        "outputId": "5b43dcc7-e7e9-43fd-888c-49e03844183d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.],\n",
              "       [ 4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.],\n",
              "       [ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n",
              "       [ 8.,  8.,  8.,  8.,  8.,  8.,  8.,  8.,  8.,  8.]])"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr2d[[2,4,6,8]]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r0F-OOK6MzCV",
        "outputId": "f38bfb6e-2618-4b7c-a331-7ae22a02c0c9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n",
              "       [ 4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.],\n",
              "       [ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.],\n",
              "       [ 7.,  7.,  7.,  7.,  7.,  7.,  7.,  7.,  7.,  7.]])"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Allows in any order\n",
        "arr2d[[6,4,2,7]]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cpWYgJYsMzCV"
      },
      "source": [
        "## More Indexing Help\n",
        "Indexing a 2d matrix can be a bit confusing at first, especially when you start to add in step size. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3xcyh6kMzCW"
      },
      "source": [
        "## Selection\n",
        "\n",
        "Let's briefly go over how to use brackets for selection based off of comparison operators."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WoBh6sbDMzCW",
        "outputId": "ae68d73a-f980-4552-9b58-c7a0df6fd0aa"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 180,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr = np.arange(1,11)\n",
        "arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yALJNuiCMzCW",
        "outputId": "09a13497-d4d3-4990-e6e9-7ae8eae865b1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([False, False, False, False,  True,  True,  True,  True,  True,\n",
              "        True])"
            ]
          },
          "execution_count": 181,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr > 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "ATDwQofnMzCW"
      },
      "outputs": [],
      "source": [
        "bool_arr = arr>4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HdvgTeJ0MzCW",
        "outputId": "9ba15b4d-897e-446f-8bf6-e917e8a1976f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([False, False, False, False,  True,  True,  True,  True,  True,\n",
              "        True])"
            ]
          },
          "execution_count": 183,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "bool_arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1pNuuLBoMzCX",
        "outputId": "207e50d6-add4-4a34-e6cc-32087f083f97"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 184,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr[bool_arr]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R1fNpyucMzCX",
        "outputId": "6b6027a7-f000-4614-e143-4c510877a57e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 185,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr[arr>2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4fdl6u3wMzCX",
        "outputId": "c2472804-1701-4c16-aec6-51f52945597e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 186,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = 2\n",
        "arr[arr>x]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "3m5wmx6QMzCY"
      },
      "source": [
        "# NumPy Operations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z28LV8v3MzCY"
      },
      "source": [
        "## Arithmetic\n",
        "\n",
        "You can easily perform array with array arithmetic, or scalar with array arithmetic. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "U2AVxC9bMzCY"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "arr = np.arange(0,10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7nNsfNNbMzCY",
        "outputId": "c4540a2f-b5d2-4cc8-f0b0-8b6c8f7f5bb0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
            ]
          },
          "execution_count": 188,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr + arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Li3bHCSMzCY",
        "outputId": "5ae16fd3-bd17-4ca9-e33b-e81981370466"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
            ]
          },
          "execution_count": 189,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr * arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0SS5aG7hMzCZ",
        "outputId": "29a77079-1651-479c-f63f-173c232f08da"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
            ]
          },
          "execution_count": 190,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr - arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eAd83h0vMzCZ",
        "outputId": "bbf3502e-76bc-44d2-a38c-33323c1ebf6e"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/Users/marci/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
            "  if __name__ == '__main__':\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([ nan,   1.,   1.,   1.,   1.,   1.,   1.,   1.,   1.,   1.])"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Warning on division by zero, but not an error!\n",
        "# Just replaced with nan\n",
        "arr/arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u3WINanJMzCZ",
        "outputId": "a6c24f44-f80c-4164-fb5a-757dd90197fa"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in true_divide\n",
            "  \n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([       inf, 1.        , 0.5       , 0.33333333, 0.25      ,\n",
              "       0.2       , 0.16666667, 0.14285714, 0.125     , 0.11111111])"
            ]
          },
          "execution_count": 191,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Also warning, but not an error instead infinity\n",
        "1/arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xcCdtzcoMzCZ",
        "outputId": "6b8afba6-544c-4f44-d06b-5edf00ceaae7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr**3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2jFoIf2LMzCa"
      },
      "source": [
        "## Universal Array Functions\n",
        "\n",
        "Numpy comes with many [universal array functions](http://docs.scipy.org/doc/numpy/reference/ufuncs.html), which are essentially just mathematical operations you can use to perform the operation across the array. Let's show some common ones:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o0My8zCwMzCa",
        "outputId": "05989f49-566e-41a7-b675-1f55545a03af"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.        ,  1.        ,  1.41421356,  1.73205081,  2.        ,\n",
              "        2.23606798,  2.44948974,  2.64575131,  2.82842712,  3.        ])"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Taking Square Roots\n",
        "np.sqrt(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I83ifGEOMzCa",
        "outputId": "da7d194f-47c9-45a0-c9e3-46564bfaf4cf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([  1.00000000e+00,   2.71828183e+00,   7.38905610e+00,\n",
              "         2.00855369e+01,   5.45981500e+01,   1.48413159e+02,\n",
              "         4.03428793e+02,   1.09663316e+03,   2.98095799e+03,\n",
              "         8.10308393e+03])"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Calcualting exponential (e^)\n",
        "np.exp(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KoPb1k3oMzCa",
        "outputId": "fb208d0a-9dae-424a-b390-a93efd3e29c6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.max(arr) #same as arr.max()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R7adquk_MzCb",
        "outputId": "913ce00d-35eb-4c7c-fdc3-999b622f97c5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,\n",
              "       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849])"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.sin(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EdfBcrGqMzCb",
        "outputId": "42da2fff-5fa2-47b3-fb4d-fd4d4df006f0"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/Users/marci/anaconda/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: divide by zero encountered in log\n",
            "  if __name__ == '__main__':\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([       -inf,  0.        ,  0.69314718,  1.09861229,  1.38629436,\n",
              "        1.60943791,  1.79175947,  1.94591015,  2.07944154,  2.19722458])"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.log(arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zXk_4JmaMzCc"
      },
      "source": [
        "# Object Oriented Programming"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OcGenCbrMzCc"
      },
      "source": [
        "#### Python is a multi-paradigm programming language. It supports different programming approaches."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOzj8tr2MzCc"
      },
      "source": [
        "One of the popular approaches to solve a programming problem is by creating objects. This is known as Object-Oriented Programming (OOP).\n",
        "\n",
        "An object has two characteristics:\n",
        "* attributes\n",
        "* behavior\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qYm5lttMzCc"
      },
      "source": [
        "#### Let's take an example:\n",
        "A parrot is an object, as it has the following properties:\n",
        "\n",
        "name, age, color as attributes singing, dancing as behavior\n",
        "\n",
        "The concept of OOP in Python focuses on creating reusable code. This concept is also known as DRY (Don't Repeat Yourself)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y3SzsI8DMzCc"
      },
      "source": [
        "# Class\n",
        "A class is a blueprint for the object.\n",
        "\n",
        "We can think of class as a sketch of a parrot with labels. It contains all the details about the name, colors, size etc. Based on these descriptions, we can study about the parrot. Here, a parrot is an object.\n",
        "\n",
        "The example for class of parrot can be :"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EQ02ranYMzCd"
      },
      "outputs": [],
      "source": [
        "class Parrot:\n",
        "    pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6HK0uXsoMzCd"
      },
      "source": [
        "Here, we use the class keyword to define an empty class Parrot. From class, we construct instances. An instance is a specific object created from a particular class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gxZWDXLbMzCd"
      },
      "source": [
        "# Object\n",
        "An object (instance) is an instantiation of a class. When class is defined, only the description for the object is defined. Therefore, no memory or storage is allocated.\n",
        "\n",
        "The example for object of parrot class can be:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VZiMxT54MzCd"
      },
      "outputs": [],
      "source": [
        "obj = Parrot()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtbcp3hQMzCd"
      },
      "source": [
        "Here, obj is an object of class Parrot.\n",
        "\n",
        "Suppose we have details of parrots. Now, we are going to show how to build the class and objects of parrots."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-bYnG3vCMzCe",
        "outputId": "f6b56ab1-45ec-42d2-b823-0eaf25837511"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Check\n",
            "Birdy\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "# We created a class with the name Parrot. \n",
        "class Parrot:\n",
        "\n",
        "    def check(self):\n",
        "      print(\"Check\")\n",
        "\n",
        "\n",
        "    # instance attribute\n",
        "    def config(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        print(name)\n",
        "        print(age)\n",
        "\n",
        "\n",
        "#Created a object\n",
        "obj = Parrot()\n",
        "\n",
        "\n",
        "# Parrot.check(obj)\n",
        "# Parrot.config(obj,'Birdy',5)\n",
        "\n",
        "# We can directly use object\n",
        "obj.check()\n",
        "obj.config('Birdy',5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YWyM6mcx5jNc"
      },
      "source": [
        "##### Instance\n",
        "We create instances of the Parrot class. Here, blu and woo are references (value) to our new objects"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cmcgl3h_4bM5",
        "outputId": "30778328-e999-4cbc-a1df-645a2b8ac958"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Called automatically\n",
            "Called automatically\n"
          ]
        }
      ],
      "source": [
        "# We created a class with the name Parrot. \n",
        "# Then, we define attributes. The attributes are a characteristic of an object.\n",
        "\n",
        "class Parrot:\n",
        "\n",
        "    # instance attribute\n",
        "    def __init__(self):\n",
        "        print(\"Called automatically\")\n",
        "\n",
        "    def check(self):\n",
        "      print(\"Check\")\n",
        "\n",
        "\n",
        "    # instance attribute\n",
        "    def config(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        print(name)\n",
        "        print(age)\n",
        "    \n",
        "\n",
        "#  we create instances of the Parrot class. Here, blu and woo are references (value) to our new objects\n",
        "# instantiate the Parrot class\n",
        "blu = Parrot()\n",
        "woo = Parrot()\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pz04NwJtLuFO",
        "outputId": "470f9017-bb56-4375-9bed-a2b28fd66942"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "show\n",
            "show\n",
            "Color is :  Green\n",
            "Size is :  4\n",
            "Color is :  Blue\n",
            "Size is :  5\n"
          ]
        }
      ],
      "source": [
        "class Parrot:\n",
        "\n",
        "    # Now we are passing variables in our init function\n",
        "    def __init__(self,color,size):\n",
        "        self.color = color\n",
        "        self.size = size\n",
        "        print(\"show\")\n",
        "\n",
        "    # instance attribute\n",
        "    def config(self):\n",
        "        print(\"Color is : \",self.color)\n",
        "        print(\"Size is : \",self.size)\n",
        "\n",
        "obj = Parrot('Gnree',4)\n",
        "obj2 = Parrot('Blue',5)\n",
        "\n",
        "obj.config()\n",
        "obj2.config()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tN9s1052MzCe"
      },
      "source": [
        "### Overview\n",
        "\n",
        "In the above program, we created a class with the name Parrot. \n",
        "\n",
        "These attributes are defined inside the init method of the class. It is the initializer method that is first run as soon as the object is created.\n",
        "\n",
        "Then, we create instances of the Parrot class. Here, blu and woo are references (value) to our new objects.\n",
        "\n",
        "Similarly, we access the instance attributes using blu.name and blu.age. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DGs9To6CMzCe"
      },
      "source": [
        "# Great Job!\n",
        "\n",
        "That's all we need to know for now!\n",
        "\n",
        "Check out the github link for assignment :\n",
        "https://github.com/utkarsh-iitbhu/Python-Workshop\n",
        "\n",
        "For git and github tutorial you can refer too : \n",
        "https://youtube.com/playlist?list=PLLt4yMoVgczVgFcTzT60U5IXtNX1qjHL9\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35yMpBvtgXEm"
      },
      "source": [
        "## Check out some cool projects in python \n",
        "\n",
        "https://github.com/recognai/rubrix\n",
        "\n",
        "https://github.com/httpie/httpie\n",
        "\n",
        "https://github.com/ActivityWatch/activitywatch\n",
        "\n",
        "https://github.com/adamghill/django-unicorn\n",
        "\n",
        "https://github.com/sherlock-project/sherlock\n",
        "\n",
        "https://github.com/vinta/awesome-python\n",
        "\n",
        "https://github.com/Ciphey/Ciphey\n",
        "\n",
        "https://github.com/encode/django-rest-framework"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "LwzdirJJMzBQ",
        "gGO0RBRCMzBT",
        "2MbG65ABMzBY",
        "eF8n8yHaMzBa",
        "mFYDT7a-MzBb",
        "msmiPgUDMzBc",
        "grPyNlBnMzBc",
        "2fNO3LlQMzBf",
        "P1vNSet5MzBg",
        "yv88aEzhMzBp",
        "E4yI7jLuMzBr",
        "hI_N68yqMzBr",
        "YaBgpSYlMzBs",
        "HyxbSTNWMzBt",
        "vehYCw-OMzBv",
        "5Pt7LcbxMzBw",
        "c9Vk0RMTMzBz",
        "jsiXgqaAMzB5",
        "8Bsrtc3OMzB9",
        "IOKc9i8sMzB9",
        "WcKJ8vA6MzB-",
        "o1lFDQK8MzB-",
        "GI3wYdzbMzCA",
        "jDIxTmT9MzCA",
        "YVgr-TZsMzCB",
        "JCzg9f5OMzCC",
        "a8jb4Pl1MzCD",
        "wkD34NhOMzCE",
        "xyn_guW0MzCF",
        "4MQTfhm2MzCG",
        "50hWEtl1MzCH",
        "XnsPCaA-MzCI",
        "8UyCgkYzMzCI",
        "wUgIcHB0MzCK",
        "zz_0umGqMzCM",
        "Sqdy4jUJMzCM",
        "1F8PtmEKMzCN",
        "VCyo8fi_MzCO",
        "-YllIwk8MzCR",
        "8L1Ms6D3MzCU",
        "cpWYgJYsMzCV",
        "f3xcyh6kMzCW",
        "3m5wmx6QMzCY",
        "z28LV8v3MzCY",
        "2jFoIf2LMzCa",
        "zXk_4JmaMzCc",
        "OcGenCbrMzCc",
        "3qYm5lttMzCc",
        "Y3SzsI8DMzCc",
        "gxZWDXLbMzCd",
        "tN9s1052MzCe",
        "DGs9To6CMzCe",
        "35yMpBvtgXEm"
      ],
      "name": "Python_guide.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}