Python_Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python-Basics.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "rjnfmNQ-bY4h"
      ]
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CWIM41HQbYwa",
        "_uuid": "c9735cb1fe3aca20c218cd06131e3722e2cd2e00"
      },
      "source": [
        "# Python Basics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tkSQCyYNbYwv",
        "_uuid": "01b434b5e9ed00f75aa01cecc201f5c6a0d89f30"
      },
      "source": [
        "## 1. Individual things\n",
        "\n",
        "The most basic component of any programming language are \"things\", also called variables or\n",
        "(in special cases) objects.\n",
        "\n",
        "The most common basic \"things\" in Python are integers, floats, strings, booleans, and\n",
        "some special objects of various types. We'll meet many of these as we go through the lesson."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B1GGFr_yKM-x"
      },
      "source": [
        "This is a **Jupyter Notebook**, that we'll use for all the python tutorials.<br>\n",
        "The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text.<br>\n",
        "It is more readable and better to create notes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WRggBcTibYw8",
        "_uuid": "2252404234717fa3305600732db8dcf943aadcdb"
      },
      "source": [
        "__TIP:__ To run the code in a cell quickly, press Ctrl+Enter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vTpWeCKCbYw-",
        "_uuid": "79c6f8a6f2ac2332efaa1c404ffc847d02240c07"
      },
      "source": [
        "__TIP:__ To run the code in a cell and move to next cell, press Shift+Enter"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8HOy71WqbYxB",
        "trusted": false,
        "_uuid": "3c549dc22b6c574faeede0180c128e5a02169cd8",
        "outputId": "a424fb4f-f37b-4e53-90bb-a37faa1350a6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# A thing\n",
        "2"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dCoCqUzybYxZ",
        "trusted": false,
        "_uuid": "7babbdff6709a1ba80fec1ef880322cfe7d70f1e",
        "outputId": "31d8b05e-4c66-40bd-c631-1ae9eb104cb4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Use print to show multiple things in the same cell\n",
        "# Note that you can use single or double quotes for strings\n",
        "print(2)\n",
        "print('hello')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hp6bVMGtbYxl",
        "trusted": false,
        "_uuid": "8dbfdfc353adfba9efd8cd65f761874e740d8b2c",
        "outputId": "20e4ecba-629c-4b84-f23b-cfaf5831e3ae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Things can be stored as variables\n",
        "a = 2\n",
        "b = 'hello'\n",
        "c = True  # This is case sensitive\n",
        "print(a, b, c)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2 hello True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cX5XLGcjbYx1",
        "trusted": false,
        "_uuid": "4e664f44a7297b746e3a2f70250732ba5027ae9c",
        "outputId": "d0e85ef1-5d9f-418b-8cdf-00736befcc34",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# The type function tells us the type of a variable we have\n",
        "print(type(a))\n",
        "print(type(b))\n",
        "print(type(c))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'str'>\n",
            "<class 'bool'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dt2EWRijbYyB",
        "trusted": false,
        "_uuid": "5c7a281d884fd2f44aa79f7266ee2e475429801c",
        "outputId": "a20471fe-163d-4e1a-e8c1-556b95a1a6f0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# What happens when a new variable point to a previous variable?\n",
        "a = 1\n",
        "b = a\n",
        "a = 2\n",
        "## What is b?\n",
        "print(a,b)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IcfnF45Db5qD",
        "trusted": false,
        "_uuid": "e607b506e35ed828ca0933f36a3c3a04656de4cf",
        "outputId": "9815d348-e840-4728-86dd-1cd64ec5f1c2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "a= 3\n",
        "b=4 \n",
        "a,b = b,a  # program to swap two variables in just one line \"in Python\"\n",
        "print(a,b)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9nfKVHSbYyQ",
        "_uuid": "e7696e7ef781b57ad7daab6be78d686380f63e48"
      },
      "source": [
        "\n",
        "## 2. Commands that operate on things\n",
        "\n",
        "Just storing data in variables isn't much use to us. Right away, we'd like to start performing\n",
        "operations and manipulations on data and variables.\n",
        "\n",
        "There are three very common means of performing an operation on a thing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0XKP22sbbYyU",
        "_uuid": "da9950854d72ce38fc25ece21a83ab6a39750090"
      },
      "source": [
        "### 2.1 Use an operator\n",
        "\n",
        "All of the basic math operators work like you think they should for numbers. They can also\n",
        "do some useful operations on other things, like strings. There are also boolean operators that\n",
        "compare quantities and give back a `bool` variable as a result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zzMZWCTXbYyW",
        "trusted": false,
        "_uuid": "55cd487f4066b5fad52ba7913d98853757fca454",
        "outputId": "bbac2abe-5125-475f-88d4-a45fc442cb58",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Standard math operators work as expected on numbers\n",
        "a = 5\n",
        "b = 2\n",
        "print(a + b)\n",
        "print(a * b)\n",
        "print(a ** b)  # a to the power of b (a^b does something completely different!)\n",
        "print(a / b)   # always return float type variable\n",
        "print(a//b)    # always return the integer part of the answer (also called floor division)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "10\n",
            "25\n",
            "2.5\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hPzZTql-bYyu",
        "trusted": false,
        "_uuid": "bb2b9266fe5e9952f95d51c9d734af814d77e5b2",
        "outputId": "3d8c1424-bc8b-42bc-a04d-429b2faf357d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# There are also operators for strings\n",
        "print('hello' + 'world')\n",
        "print('hello' * 3)\n",
        "#print('hello' / 3)  # You can't do this!"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "helloworld\n",
            "hellohellohello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VWB6zTEnbYy6",
        "trusted": false,
        "_uuid": "a8dddbd1af6de6fadd427dfa0a73a83f1e62aaa6",
        "outputId": "36469a8b-ddd5-4452-8370-3f896ade3bab",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Boolean operators compare two things\n",
        "a = (1 > 3)\n",
        "b = (3 == 3)\n",
        "print(a)\n",
        "print(b)\n",
        "print(a or b)\n",
        "print(a and b)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yDMOvQnNbYzP",
        "_uuid": "1c23eddf1725a5593eaa7204706f2373729b409a"
      },
      "source": [
        "### 2.2 Use a built-in function\n",
        "\n",
        "These will be very familiar to anyone who has programmed in any language, and work like you\n",
        "would expect."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "po0fZkERbYzR",
        "trusted": false,
        "_uuid": "8ba8d55d548f41bd1df0faab483d66138279ee8e",
        "outputId": "e7b5dcaf-05af-47d3-9672-2d3d1d1f32fe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# There are thousands of functions that operate on things\n",
        "print(type(3))\n",
        "print(len('hello'))\n",
        "print(round(3.3)) # to get the round off"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "5\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n-eAqbCkbYzY",
        "_uuid": "005bff01def0a74f89c571963831f19786308162"
      },
      "source": [
        "__TIP:__ To find out what a function does, you can type it's name and then a question mark and press Ctrl+Enter to\n",
        "get a pop up help window. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tebsIqcU5KPg"
      },
      "source": [
        "round?"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WCU3cqEQbYze",
        "trusted": false,
        "_uuid": "2f337d83cd7c837e334a74a17c12c55bf6c3ecd1",
        "outputId": "d0b39b4e-bfec-48ca-8c13-2df392aa03f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "round(3.14159, 2)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ob8b372hbY0T",
        "_uuid": "58d0f1d5f0972a4295b0425227395e0c368bafb3"
      },
      "source": [
        "### 2.3 Use a method\n",
        "\n",
        "Before we get any farther into the Python language, we have to say a word about \"objects\". We\n",
        "will not be teaching object oriented programming in this workshop, but you will encounter objects\n",
        "throughout Python (in fact, even seemingly simple things like ints and strings are actually\n",
        "objects in Python).\n",
        "\n",
        "In the simplest terms, you can think of an object as a small bundled \"thing\" that contains within\n",
        "itself both data and functions that operate on that data. For example, strings in Python are\n",
        "objects that contain a set of characters and also various functions that operate on the set of\n",
        "characters. When bundled in an object, these functions are called \"methods\".\n",
        "\n",
        "Instead of the \"normal\" `function(arguments)` syntax, methods are called using the\n",
        "syntax `variable.method(arguments)`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9SSj-yGbY0c",
        "trusted": false,
        "_uuid": "b5e8bda926050a39a05446d6d3667c792bfeb995",
        "outputId": "fac3d23a-bc01-4757-e509-2b1d974a3654",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# A string is actually an object\n",
        "a = 'hello, world'\n",
        "print(type(a))"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OizL8VO4bY0s",
        "trusted": false,
        "_uuid": "6e64fa54e861835477b238095c1c1c72767f3fc9",
        "outputId": "4d29880b-9dc9-459b-ee96-1f6f415be145",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Objects have bundled methods\n",
        "#a.\n",
        "print(a.capitalize())\n",
        "print(a.replace('l', 'X'))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, world\n",
            "heXXo, worXd\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DCxHce2YbY1Y",
        "_uuid": "a825b6d8cbe782715ad168bd8ef682470cee85b3"
      },
      "source": [
        "## 3. Collections of things (built-in Data Structures)\n",
        "\n",
        "While it is interesting to explore your own height, in science we work with larger  slightly more complex datasets. In this example, we are interested in the characteristics and distribution of heights. Python provides us with a number of objects to handle collections of things.\n",
        "\n",
        "Probably 99% of your work in scientific Python will use one of four types of collections:\n",
        "`lists`, `tuples`, `dictionaries`, and `numpy arrays`. We'll look quickly at each of these and what\n",
        "they can do for you."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wxKkGwCobY1h",
        "_uuid": "d587a814d449a977282704f60578ffe1f1a2588e"
      },
      "source": [
        "### 3.1 Lists\n",
        "\n",
        "Lists are probably the handiest and most flexible type of container. \n",
        "\n",
        "Lists are declared with square brackets []. \n",
        "\n",
        "Individual elements of a list can be selected using the syntax `a[ind]`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XUoly0D5bY1p",
        "trusted": false,
        "_uuid": "04b7f8a20909608f6a5e3d409ca75281d3b9f01a",
        "outputId": "fe1bdfac-acef-4cc4-8d08-875173b8e9c6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Lists are created with square bracket syntax\n",
        "a = ['blueberry', 'strawberry', 'pineapple']\n",
        "print(a, type(a))"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['blueberry', 'strawberry', 'pineapple'] <class 'list'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pyjHheZkbY2H",
        "trusted": false,
        "_uuid": "2cfd20b8e6d8afdd05ebdcdeb89bc7fabb0db5be",
        "outputId": "6e3a6ebe-8655-47bd-bb39-b966a64515eb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Lists (and all collections) are also indexed with square brackets\n",
        "# NOTE: The first index is zero, not one\n",
        "print(a[0])\n",
        "print(a[1])"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "blueberry\n",
            "strawberry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QzFE3uXfbY2a",
        "trusted": false,
        "_uuid": "b7400c19d73f847facc3ff400586b7f289675183",
        "outputId": "9a06ba91-7959-4570-e5ed-db27cbcdfb73",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "## You can also count from the end of the list\n",
        "print('last item is:', a[-1])\n",
        "print('second to last item is:', a[-2])"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "last item is: pineapple\n",
            "second to last item is: strawberry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7WqzAuiNbY2m",
        "trusted": false,
        "_uuid": "7ba5818e7ecad669eebf51fdee658be9cea1ca1e",
        "outputId": "12936a71-600a-4567-a030-193bd7145532",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# you can access multiple items from a list by slicing, using a colon between indexes\n",
        "# NOTE: The end value is not inclusive\n",
        "print('a =', a)\n",
        "print('get first two:', a[0:2])"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a = ['blueberry', 'strawberry', 'pineapple']\n",
            "get first two: ['blueberry', 'strawberry']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D5YmRt_nbY2_",
        "trusted": false,
        "_uuid": "5eb34ac4f044c6529ede137e2f386e066b796365",
        "outputId": "98cdfa03-16e3-4246-dea7-b12fbfc26a81",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# You can leave off the start or end if desired\n",
        "print(a[:2])\n",
        "print(a[2:])\n",
        "print(a[:])\n",
        "print(a[:-1])"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['blueberry', 'strawberry']\n",
            "['pineapple']\n",
            "['blueberry', 'strawberry', 'pineapple']\n",
            "['blueberry', 'strawberry']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T_DzS8qobY3l",
        "trusted": false,
        "_uuid": "899db1b81e21de205394e04eef122c279ffffae3",
        "outputId": "ab27df31-9eed-481f-e87f-cea437846542",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Lists are objects, like everything else, and have methods such as append\n",
        "a.append('banana')\n",
        "print(a)\n",
        "\n",
        "a.append([1,2])  # list can store multiple data types\n",
        "print(a)\n",
        "\n",
        "a.pop()  # to remove an element from the last\n",
        "print(a)\n",
        "\n",
        "a.pop(0)  # to remove an element at index=0\n",
        "print(a)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['blueberry', 'strawberry', 'pineapple', 'banana', 'banana', 'banana']\n",
            "['blueberry', 'strawberry', 'pineapple', 'banana', 'banana', 'banana', [1, 2]]\n",
            "['blueberry', 'strawberry', 'pineapple', 'banana', 'banana', 'banana']\n",
            "['strawberry', 'pineapple', 'banana', 'banana', 'banana']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pCwexpsZbY3x",
        "_uuid": "b7098424a43a81c177872f7f69cc2a8204369635"
      },
      "source": [
        "# __TIP:__ A 'gotcha' for some new Python users is that many collections, including lists,\n",
        "actually store pointers to data, not the data itself. \n",
        "\n",
        "Remember when we set `b=a` and then changed `a`?\n",
        "\n",
        "What happens when we do this in a list?\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m8Gz88w-bY38",
        "trusted": false,
        "_uuid": "de8859191287caa5fa5097d5180ff1b109e764de",
        "outputId": "aa84455b-c0b8-4cb5-9428-cd9346460e1b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "a = 1\n",
        "b = a\n",
        "a = 2\n",
        "## What is b?\n",
        "print('What is b?', b)\n",
        "\n",
        "a = [1, 2, 3]\n",
        "b = a\n",
        "print('original b', b)\n",
        "a[0] = 42\n",
        "print('What is b after we change a ?', b)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "What is b? 1\n",
            "original b [1, 2, 3]\n",
            "What is b after we change a ? [42, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kfpKGTOrbY4c",
        "_uuid": "32dd47b3d5aa8b8f69d1ce62fb66dea827967801"
      },
      "source": [
        "### 3.2 Tuples\n",
        "\n",
        "We won't say a whole lot about tuples except to mention that they basically work just like lists, with\n",
        "two major exceptions:\n",
        "\n",
        "1. You declare tuples using () instead of []\n",
        "1. Once you make a tuple, you can't change what's in it (referred to as immutable)\n",
        "\n",
        "You'll see tuples come up throughout the Python language, and over time you'll develop a feel for when\n",
        "to use them. \n",
        "\n",
        "In general, they're often used instead of lists:\n",
        "\n",
        "1. to group items when the position in the collection is critical, such as coord = (x,y)\n",
        "1. when you want to make prevent accidental modification of the items, e.g. shape = (12,23)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sg1Gt_W8bY4d",
        "trusted": false,
        "_uuid": "b3dfee004f960e4d9999454b95c1f971774c6099",
        "outputId": "6c55ae60-d315-472b-de86-523e5fae3cd8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 230
        }
      },
      "source": [
        "xy = (23, 45)\n",
        "print(xy[0])\n",
        "xy[0] = \"this won't work with a tuple\""
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "23\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-33-2b1e2849198f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mxy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m23\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m45\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mxy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"this won't work with a tuple\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjnfmNQ-bY4h",
        "_uuid": "2504751ae21bd415187532395487758f6c9de6fe"
      },
      "source": [
        "### Anatomy of a traceback error\n",
        "\n",
        "Traceback errors are `raised` when you try to do something with code it isn't meant to do.  It is also meant to be informative, but like many things, it is not always as informative as we would like.\n",
        "\n",
        "Looking at our error:\n",
        "\n",
        "    TypeError                                 Traceback (most recent call last)\n",
        "    <ipython-input-25-4d15943dd557> in <module>()\n",
        "          1 xy = (23, 45)\n",
        "          2 xy[0]\n",
        "    ----> 3 xy[0] = 'this wont work with a tuple'\n",
        "\n",
        "    TypeError: 'tuple' object does not support item assignment\n",
        "    \n",
        "1. The command you tried to run raise a **TypeError**  This suggests you are using a variable in a way that its **Type** doesnt support\n",
        "2. the arrow ----> points to the line where the error occurred, In this case on line 3 of your code form the above line.\n",
        "3. Learning how to **read** a traceback error is an important skill to develop, and helps you know how to ask questions about what has gone wrong in your code.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LMOIeEsbbY4j",
        "_uuid": "c64b77f3f57b63d6e7ef34d3a0164f5a628a7bc5"
      },
      "source": [
        "### 3.3 Dictionaries\n",
        "\n",
        "Dictionaries are the collection to use when you want to store and retrieve things by their names\n",
        "(or some other kind of key) instead of by their position in the collection. A good example is a set\n",
        "of model parameters, each of which has a name and a value. Dictionaries are declared using {}."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JzRLqw9ybY4l",
        "trusted": false,
        "_uuid": "e50941e71a68e76608aa4952f7908eefbc998f9c",
        "outputId": "a53580af-5fea-4689-ec7e-04fa61437e57",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Make a dictionary of model parameters\n",
        "convertors = {'inches_in_feet' : 12,\n",
        "              'inches_in_metre' : 39}\n",
        "\n",
        "print(convertors)\n",
        "print(convertors['inches_in_feet'])"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'inches_in_feet': 12, 'inches_in_metre': 39}\n",
            "12\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w7Yj3Y9lbY4q",
        "trusted": false,
        "_uuid": "c4702a5221a27b0423c24bcae2adc7ab537ef00e",
        "outputId": "8284478f-f5b5-4ffc-926d-774986e050a4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "## Add a new key:value pair\n",
        "convertors['metres_in_mile'] = 1609.34\n",
        "print(convertors)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'inches_in_feet': 12, 'inches_in_metre': 39, 'metres_in_mile': 1609.34}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DHb4kVojbY4w",
        "trusted": false,
        "_uuid": "44274821fa1b03da8655720435f44d398af34220",
        "outputId": "a79aa2bc-91db-42a5-b823-24ae98d3f20b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        }
      },
      "source": [
        "# Raise a KEY error\n",
        "print(convertors['blueberry'])"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-36-f7653b7ac342>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Raise a KEY error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconvertors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'blueberry'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'blueberry'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WquMKmAx-vjy"
      },
      "source": [
        "__Some commonly used methods of dictionaries__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I9nZXpIn-u5g",
        "outputId": "fa38f0d2-78a8-4bb2-9e03-6767f4706dbc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(\"Keys in Converters:  \", convertors.keys())\n",
        "print(\"Values in Converters:  \", convertors.values())\n",
        "print(\"Items in Converters:  \", convertors.items())"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Keys in Converters:   dict_keys(['inches_in_feet', 'inches_in_metre', 'metres_in_mile'])\n",
            "Values in Converters:   dict_values([12, 39, 1609.34])\n",
            "Items in Converters:   dict_items([('inches_in_feet', 12), ('inches_in_metre', 39), ('metres_in_mile', 1609.34)])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7PQjofVI8pS5"
      },
      "source": [
        "This means blueberry is not a key inside this dictionary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T3K3bxxj-fHH"
      },
      "source": [
        "### 3.4 Sets\n",
        "\n",
        "Sets is a collection of unique elements, also it is immutable. It is also an unordered data structure. No matter in what order you add the values in the set, it will always show the values in any random order."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXX0Gxkd-syC",
        "outputId": "554c396e-9bf8-4e92-9922-f7453fb2dc40",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "s = {1, 2, 3}\n",
        "print(s, type(s))\n",
        "\n",
        "s = {1, 1, 2, 2, 3, 3} # it will take each element once\n",
        "\n",
        "print(s, type(s))"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{1, 2, 3} <class 'set'>\n",
            "{1, 2, 3} <class 'set'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "35uuHAym_5k3"
      },
      "source": [
        "# s[0] = 0   you can't do this as set is immutable"
      ],
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiIay9b7_t90"
      },
      "source": [
        "__Some common methods of sets__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sVwIqJKU_tp8",
        "outputId": "75368cd4-8d56-4c62-e192-1d3a4c646b8d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "s.add('a')\n",
        "print(s)\n",
        "\n",
        "s.remove('a')\n",
        "print(s)"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{1, 2, 3, 'a'}\n",
            "{1, 2, 3}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LxABcfeZAfD4"
      },
      "source": [
        "Also you can use any set method, like union, intersection  etc that you have learnt in mathematics."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jv7s7UzgAWyT",
        "outputId": "18abfe3b-7a31-4b45-f112-ca2acf6b8638",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "s2 = {3,8,9}\n",
        "\n",
        "print(\"Union:  \",s.union(s2))\n",
        "\n",
        "print(\"Intersection:  \", s.intersection(s2))"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Union:   {1, 2, 3, 8, 9}\n",
            "Intersection:   {3}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QWTHveTbbY6m",
        "_uuid": "c21a4addf99d43467d9861a6189ce5a51d949298"
      },
      "source": [
        "## 4. Repeating yourself - Loops in Python\n",
        "\n",
        "So far, everything that we've done could, in principle, be done by hand calculation. In this section\n",
        "and the next, we really start to take advantage of the power of programming languages to do things\n",
        "for us automatically.\n",
        "\n",
        "We start here with ways to repeat yourself. The two most common ways of doing this are known as for\n",
        "loops and while loops. For loops in Python are useful when you want to cycle over all of the items\n",
        "in a collection (such as all of the elements of an array), and while loops are useful when you want to\n",
        "cycle for an indefinite amount of time until some condition is met.\n",
        "\n",
        "The basic examples below will work for looping over lists, tuples, and arrays. Looping over dictionaries\n",
        "is a bit different, since there is a key and a value for each item in a dictionary. Have a look at the\n",
        "Python docs for more information."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B9VU7h6xbY6o",
        "trusted": false,
        "_uuid": "f4d595606b8441cef38bd054952683d5dd245bf4",
        "outputId": "4f601789-57c4-4ce9-cac6-baa69c13ef70",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# A basic for loop - don't forget the white space(the indentation)!\n",
        "wordlist = ['hi', 'hello', 'bye']\n",
        "for word in wordlist:\n",
        "    print(word + '!')"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hi!\n",
            "hello!\n",
            "bye!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-bkL83AebY6r",
        "_uuid": "50e4769c66db10f315bcdbd99c725eaa8ae3592b"
      },
      "source": [
        "**Note on indentation**: Notice the indentation once we enter the for loop.  Every idented statement after the for loop declaration is part of the for loop.  This rule holds true for while loops, if statements, functions, etc. Required identation is one of the reasons Python is such a beautiful language to read.\n",
        "\n",
        "If you do not have consistent indentation you will get an `IndentationError`.  Fortunately, most code editors will ensure your indentation is correction.\n",
        "\n",
        "__NOTE__ In Python the default is to use four (4) spaces for each indentation, most editros can be configured to follow this guide."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1vFPe3jbY6r",
        "trusted": false,
        "_uuid": "ad27db71aa8c6fb5089f9f21edcb123e955082f3",
        "outputId": "61e80b59-3fca-4152-8592-82f737fa8ed9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        }
      },
      "source": [
        "# Indentation error: Fix it!\n",
        "for word in wordlist:\n",
        "    new_word = word.capitalize()\n",
        "   print(new_word + '!') # Bad indent"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-38-ea6f04fa86bc>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print(new_word + '!') # Bad indent\u001b[0m\n\u001b[0m                                      ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FKwYbTTZbY60",
        "trusted": false,
        "_uuid": "5834e1d014b3da3450c9fba546f210cc4d872c8d",
        "outputId": "9fa1d5eb-7a68-4db5-8d17-ff424e2afb99",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Sum all of the values in a collection using a for loop\n",
        "numlist = [1, 4, 77, 3]\n",
        "\n",
        "total = 0\n",
        "for num in numlist:\n",
        "    total = total + num\n",
        "    \n",
        "print(\"Sum is\", total)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sum is 85\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F3Fbg1z9bY62",
        "trusted": false,
        "_uuid": "3734ae424fd6dd9d2e8546f189293992e99e7c54",
        "outputId": "2c1876d7-bf57-43be-81bb-bb9bcc36d5a3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Often we want to loop over the indexes of a collection, not just the items\n",
        "print(wordlist)\n",
        "\n",
        "for i, word in enumerate(wordlist):\n",
        "    print(i, word, wordlist[i])"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hi', 'hello', 'bye']\n",
            "0 hi hi\n",
            "1 hello hello\n",
            "2 bye bye\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yI2tKk6AbY7T",
        "trusted": false,
        "_uuid": "cddb52158ef4f3ce9b5b5f5901bcb397c6dc57c3",
        "outputId": "0963ffdb-539c-491a-bde6-4328deb9d1ac",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# While loops are useful when you don't know how many steps you will need,\n",
        "# and want to stop once a certain condition is met.\n",
        "step = 0\n",
        "prod = 1\n",
        "while prod < 100:\n",
        "    step = step + 1\n",
        "    prod = prod * 2\n",
        "    print(step, prod)\n",
        "    \n",
        "print('Reached a product of', prod, 'at step number', step)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 2\n",
            "2 4\n",
            "3 8\n",
            "4 16\n",
            "5 32\n",
            "6 64\n",
            "7 128\n",
            "Reached a product of 128 at step number 7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ehlHQPcdbY7d",
        "_uuid": "374a02dd4b4bee882ab0d784a69e20e40f9473a5"
      },
      "source": [
        "__TIP:__ Once we start really generating useful and large collections of data, it becomes unwieldy to\n",
        "inspect our results manually. The code below shows how to make a very simple plot of an array.\n",
        "We'll do much more plotting later on, this is just to get started."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eCtJEH1BbY75",
        "_uuid": "be0e3e77a3968d27ce81181c83cd36686a33e557"
      },
      "source": [
        "## 5. Making choices  (Conditional Statements in Python)\n",
        "\n",
        "Often we want to check if a condition is True and take one action if it is, and another action if the\n",
        "condition is False. We can achieve this in Python with an if statement.\n",
        "\n",
        "__TIP:__ You can use any expression that returns a boolean value (True or False) in an if statement.\n",
        "Common boolean operators are ==, !=, <, <=, >, >=. You can also use `is` and `is not` if you want to\n",
        "check if two variables are identical in the sense that they are stored in the same location in memory."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-H89MH-bY76",
        "trusted": false,
        "_uuid": "0dc57c3874601b50ec12bf4854ea29ece1baeef9",
        "outputId": "76b4b500-cb8c-49de-80d6-8af2ecab4851",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# A simple if statement\n",
        "x = 3\n",
        "if x > 0:\n",
        "    print('x is positive')\n",
        "elif x < 0:\n",
        "    print('x is negative')\n",
        "else:\n",
        "    print('x is zero')"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x is positive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdnAXvL7bY8E",
        "trusted": false,
        "_uuid": "2eb561da3e1601a64052a389d7cbf778fcc00adc",
        "outputId": "5c411510-c6d2-46f3-a3d1-88d02a328acf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# If statements can rely on boolean variables\n",
        "x = -1\n",
        "test = (x > 0)\n",
        "print(type(test)); print(test)\n",
        "\n",
        "if test:\n",
        "    print('Test was true')"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'bool'>\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LuvpYHwS968L"
      },
      "source": [
        "### Some commonly used Built-in Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XIDMz2LVB3uP"
      },
      "source": [
        "**TYPECASTING int()  float()  str()  bool()  list()  tuple()  dict()  set()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vVIyPtlKC9hn",
        "outputId": "6b6cfd8b-44b8-4317-e04f-b5a5548617c6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "i = 8\n",
        "print(i, type(i))\n",
        "i = float(i)   # changes the type of a vairaible to float (if possible)\n",
        "print(i, type(i))"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8 <class 'int'>\n",
            "8.0 <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "odz3pWVK6wRE"
      },
      "source": [
        "s = 'hello'\n",
        " # float(s)  you can't do this as string cannot be converted to float"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EqpgBhek-Orz",
        "outputId": "c24580db-5f3f-471d-c838-d7a15b94b5f7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "l = ['a', 'b', 1, 2, 3]\n",
        "print(l, type(l))\n",
        "\n",
        "l = tuple(l)\n",
        "print(l, type(l))"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['a', 'b', 1, 2, 3] <class 'list'>\n",
            "('a', 'b', 1, 2, 3) <class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kAAgYFeF5_Yc"
      },
      "source": [
        "**len(), sum(), max(), min()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ODGGWSBS5iG1",
        "outputId": "0f8ab47b-6118-480d-9f0a-8a726476cdb6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "l=[1, 2, 4]\n",
        "s = {1, 2, 3}\n",
        "d= {1:2, 3:4}\n",
        "print(len(l), len(s), len(d))  # returns the length"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3 3 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ijvkSvt19Y3i",
        "outputId": "b06d3b57-5939-4f0f-d066-bf6eb6814241",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(sum(l), sum(s))   # return sum"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7 6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zarg71Vc9hH8",
        "outputId": "8b5ea706-2a56-41e6-ddb1-a2b2d93bf1a1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(max(l), max(s))   # returns maximum element"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U72enIA69k3t",
        "outputId": "17643562-3794-4b08-a16f-e0aae1fdf2fa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(min(l), min(s))   # returns minimum element"
      ],
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G6M0dojY6cW4"
      },
      "source": [
        "**type()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8iGgmWQ46MJB",
        "outputId": "37ec04ea-acb3-4dea-8969-f29517a7cc8a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(type(l), type(s), type(d))    "
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'list'> <class 'set'> <class 'dict'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8oQecQ0WFwbG"
      },
      "source": [
        "**any()  all()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3QfQoi3F7fJ"
      },
      "source": [
        "__any()__  -  I there any True in the collection<br>\n",
        "__all()__  -  Is there all True in the collection"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vu1wuNGg6iTg",
        "outputId": "4b8459ba-46ec-4d09-8016-88bd868d7433",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(any(l), all(l))\n",
        "\n",
        "ll = [1, 2, 0]    # 0 always considered as False\n",
        "print(any(ll), all(ll))\n",
        "\n",
        "lll = [True, True, False]\n",
        "print(any(lll), all(lll))"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True True\n",
            "True False\n",
            "True False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBw-vMFp8JQQ"
      },
      "source": [
        "**eval()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a3z12sy0GXoA"
      },
      "source": [
        "To evaluate expressions in python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N154elh07C16",
        "outputId": "87041d67-aea0-4c05-d0a8-f8212aa73013",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "x = 2\n",
        "print(eval(\"x**2 + 2*x + 2\"))\n"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S77xJh8F9PNj"
      },
      "source": [
        "**zip()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W1Wn2_TuGiWg"
      },
      "source": [
        "Index wise merging multiple collection"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GqCs1fxl8RhV",
        "outputId": "1f295fe7-ed38-4133-f0d6-ad42ed72b1b7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "l = [1,2,3]\n",
        "ll = ['a', 'b', 'c']\n",
        "print(zip(l, ll)) # not in readable format  (Need to typecast into list)"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<zip object at 0x7fa7b1ffd608>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fqUjHUU0-GqJ",
        "outputId": "3bc7e964-046b-4e3b-97d6-5878a1a5e10e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(list(zip(l, ll)))"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[(1, 'a'), (2, 'b'), (3, 'c')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z1Eeq9G6SShn"
      },
      "source": [
        "**range()**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ErME0KDuG2Gv"
      },
      "source": [
        "Creates a sequence"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SWXnc87ASSIK",
        "outputId": "9d7b536f-67c6-4c91-c034-6043d26a617f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "print(list(range(5)))\n",
        "print(list(range(2,10)))"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4]\n",
            "[2, 3, 4, 5, 6, 7, 8, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhQqUgeMbY8X",
        "_uuid": "31e58f7704553cc8e5d1a7f613f9b414b324af1a"
      },
      "source": [
        "## 6. Creating chunks with functions and modules\n",
        "\n",
        "One way to write a program is to simply string together commands, like the ones described above, in a long\n",
        "file, and then to run that file to generate your results. This may work, but it can be cognitively difficult\n",
        "to follow the logic of programs written in this style. Also, it does not allow you to reuse your code\n",
        "easily - for example, what if we wanted to run our logistic growth model for several different choices of\n",
        "initial parameters?\n",
        "\n",
        "The most important ways to \"chunk\" code into more manageable pieces is to create functions and then\n",
        "to gather these functions into modules, and eventually packages. Below we will discuss how to create\n",
        "functions. A third common type of \"chunk\" in Python is classes, but we will not be covering\n",
        "object-oriented programming in this notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uloSrs_4bY8e",
        "trusted": false,
        "_uuid": "c384ac3e3a505768153f60aece5f94173034ee5b"
      },
      "source": [
        "# It's very easy to write your own functions\n",
        "def multiply(x, y):\n",
        "    return x*y"
      ],
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R8zzQkKFbY8m",
        "trusted": false,
        "_uuid": "ec52800586b4359a9f5f55b418a5e63432e85802",
        "outputId": "9eab5c0a-1e57-46e3-ef15-7d421af355be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Once a function is \"run\" and saved in memory, it's available just like any other function\n",
        "print(type(multiply))\n",
        "print(multiply(4, 3))"
      ],
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'function'>\n",
            "12\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GcgmxtdYbY80",
        "trusted": false,
        "_uuid": "5bf2f0fc55afeb06a0a5bb280d582b4efb441ad5"
      },
      "source": [
        "# It's useful to include docstrings to describe what your function does\n",
        "def say_hello(time, people):\n",
        "    '''\n",
        "    Function says a greeting. Useful for engendering goodwill\n",
        "    '''\n",
        "    return 'Good ' + time + ', ' + people"
      ],
      "execution_count": 73,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8APsCrUubY8-",
        "_uuid": "fd5b53959bf9ae74f9ee11f0ff127a47750f7fa0"
      },
      "source": [
        "**Docstrings**: A docstring is a special type of comment that tells you what a function does.  You can see them when you ask for help about a function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9dxcu34Iyb6"
      },
      "source": [
        "Or you can use __doc__ method with the function name to see the docstring"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "49dulv0aIu4b",
        "outputId": "198d14c5-336b-451d-ab2e-ebc6448ec71b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "say_hello.__doc__"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\n    Function says a greeting. Useful for engendering goodwill\\n    '"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NqD850ZKbY9A",
        "trusted": false,
        "_uuid": "213100a4ebd8a612c123b3c15ff671cd7ba46d4e",
        "outputId": "f0395a3b-1a40-4796-b94e-0c30aef244bb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "say_hello('afternoon', 'friends')"
      ],
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Good afternoon, friends'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cRVQcAc4bY9J",
        "trusted": false,
        "_uuid": "7b20f66d9692f220a36cc85535ea889dc8e1121f",
        "outputId": "efa6b9e0-a8a3-41c8-cca5-9290520ffda6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        }
      },
      "source": [
        "# All arguments must be present, or the function will return an error\n",
        "say_hello('afternoon')"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-77-7c90841f1c44>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# All arguments must be present, or the function will return an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msay_hello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'afternoon'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: say_hello() missing 1 required positional argument: 'people'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sVmJwv2obY9Q",
        "trusted": false,
        "_uuid": "0f7def33f101d0bc4f5c001383b3e9c9d630230c"
      },
      "source": [
        "# Keyword arguments can be used to make some arguments optional by giving them a default value\n",
        "# All mandatory arguments must come first, in order\n",
        "def say_hello(time, people='friends'):\n",
        "    return 'Good ' + time + ', ' + people"
      ],
      "execution_count": 78,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I99Sg1_cbY9d",
        "trusted": false,
        "_uuid": "dbd43d08f277c3fba901d942e79ddf50705a239b",
        "outputId": "fb15c702-908a-4080-9806-f2035e6534f8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "say_hello('afternoon')"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Good afternoon, friends'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ck8iy8OObY9j",
        "trusted": false,
        "_uuid": "68a133d4a7815dd971d86a73bb89033be5fd5d77",
        "outputId": "39b609f2-e8ff-429e-fe1a-68cde1fec9c6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "source": [
        "say_hello('afternoon', 'students')"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Good afternoon, students'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DwvOZlMKJYWL"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}