python_basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "python_basics.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vvthakral/Python-for-AI-Data-Science/blob/master/python_basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gExPeB_Z1MU7",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "#This notebook contains the basics of python language.\n",
        "#By [Vishnu Thakral](https://www.linkedin.com/in/vishnuthakral/) and [Darshan Solanki](https://www.linkedin.com/in/darshan-solanki/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gXARTE5Dq7RB",
        "colab_type": "code",
        "outputId": "1b720337-21e6-46e2-e6f2-0e835f6869cb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#Like any other language we can will start with printing Hello World.(very simple in python)\n",
        "print(\"Hello World\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2hpEu1LW38RC",
        "colab_type": "text"
      },
      "source": [
        "#Zen of Python\n",
        "The best Python practices suggested by the creator by Guido van Rossum.\n",
        "\n",
        "It's always good to abide by the zen even when you have an opportunity to show off your pythonic skills :)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cGeTKENv3l8Z",
        "colab_type": "code",
        "outputId": "74474b51-bdc0-41d4-dd11-fb76c9e1201e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 370
        }
      },
      "source": [
        "import this"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The Zen of Python, by Tim Peters\n",
            "\n",
            "Beautiful is better than ugly.\n",
            "Explicit is better than implicit.\n",
            "Simple is better than complex.\n",
            "Complex is better than complicated.\n",
            "Flat is better than nested.\n",
            "Sparse is better than dense.\n",
            "Readability counts.\n",
            "Special cases aren't special enough to break the rules.\n",
            "Although practicality beats purity.\n",
            "Errors should never pass silently.\n",
            "Unless explicitly silenced.\n",
            "In the face of ambiguity, refuse the temptation to guess.\n",
            "There should be one-- and preferably only one --obvious way to do it.\n",
            "Although that way may not be obvious at first unless you're Dutch.\n",
            "Now is better than never.\n",
            "Although never is often better than *right* now.\n",
            "If the implementation is hard to explain, it's a bad idea.\n",
            "If the implementation is easy to explain, it may be a good idea.\n",
            "Namespaces are one honking great idea -- let's do more of those!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SyHj5hbB0vof",
        "colab_type": "text"
      },
      "source": [
        "# Help \n",
        "One of the most useful function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "47v67mqw2HgF",
        "colab_type": "code",
        "outputId": "3cb76e00-44b1-4eaf-d742-31ccffbaddea",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "import math\n",
        "#To know more about each method functionality use of help is indeed help\n",
        "help(math)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on built-in module math:\n",
            "\n",
            "NAME\n",
            "    math\n",
            "\n",
            "DESCRIPTION\n",
            "    This module is always available.  It provides access to the\n",
            "    mathematical functions defined by the C standard.\n",
            "\n",
            "FUNCTIONS\n",
            "    acos(...)\n",
            "        acos(x)\n",
            "        \n",
            "        Return the arc cosine (measured in radians) of x.\n",
            "    \n",
            "    acosh(...)\n",
            "        acosh(x)\n",
            "        \n",
            "        Return the inverse hyperbolic cosine of x.\n",
            "    \n",
            "    asin(...)\n",
            "        asin(x)\n",
            "        \n",
            "        Return the arc sine (measured in radians) of x.\n",
            "    \n",
            "    asinh(...)\n",
            "        asinh(x)\n",
            "        \n",
            "        Return the inverse hyperbolic sine of x.\n",
            "    \n",
            "    atan(...)\n",
            "        atan(x)\n",
            "        \n",
            "        Return the arc tangent (measured in radians) of x.\n",
            "    \n",
            "    atan2(...)\n",
            "        atan2(y, x)\n",
            "        \n",
            "        Return the arc tangent (measured in radians) of y/x.\n",
            "        Unlike atan(y/x), the signs of both x and y are considered.\n",
            "    \n",
            "    atanh(...)\n",
            "        atanh(x)\n",
            "        \n",
            "        Return the inverse hyperbolic tangent of x.\n",
            "    \n",
            "    ceil(...)\n",
            "        ceil(x)\n",
            "        \n",
            "        Return the ceiling of x as an Integral.\n",
            "        This is the smallest integer >= x.\n",
            "    \n",
            "    copysign(...)\n",
            "        copysign(x, y)\n",
            "        \n",
            "        Return a float with the magnitude (absolute value) of x but the sign \n",
            "        of y. On platforms that support signed zeros, copysign(1.0, -0.0) \n",
            "        returns -1.0.\n",
            "    \n",
            "    cos(...)\n",
            "        cos(x)\n",
            "        \n",
            "        Return the cosine of x (measured in radians).\n",
            "    \n",
            "    cosh(...)\n",
            "        cosh(x)\n",
            "        \n",
            "        Return the hyperbolic cosine of x.\n",
            "    \n",
            "    degrees(...)\n",
            "        degrees(x)\n",
            "        \n",
            "        Convert angle x from radians to degrees.\n",
            "    \n",
            "    erf(...)\n",
            "        erf(x)\n",
            "        \n",
            "        Error function at x.\n",
            "    \n",
            "    erfc(...)\n",
            "        erfc(x)\n",
            "        \n",
            "        Complementary error function at x.\n",
            "    \n",
            "    exp(...)\n",
            "        exp(x)\n",
            "        \n",
            "        Return e raised to the power of x.\n",
            "    \n",
            "    expm1(...)\n",
            "        expm1(x)\n",
            "        \n",
            "        Return exp(x)-1.\n",
            "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
            "    \n",
            "    fabs(...)\n",
            "        fabs(x)\n",
            "        \n",
            "        Return the absolute value of the float x.\n",
            "    \n",
            "    factorial(...)\n",
            "        factorial(x) -> Integral\n",
            "        \n",
            "        Find x!. Raise a ValueError if x is negative or non-integral.\n",
            "    \n",
            "    floor(...)\n",
            "        floor(x)\n",
            "        \n",
            "        Return the floor of x as an Integral.\n",
            "        This is the largest integer <= x.\n",
            "    \n",
            "    fmod(...)\n",
            "        fmod(x, y)\n",
            "        \n",
            "        Return fmod(x, y), according to platform C.  x % y may differ.\n",
            "    \n",
            "    frexp(...)\n",
            "        frexp(x)\n",
            "        \n",
            "        Return the mantissa and exponent of x, as pair (m, e).\n",
            "        m is a float and e is an int, such that x = m * 2.**e.\n",
            "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
            "    \n",
            "    fsum(...)\n",
            "        fsum(iterable)\n",
            "        \n",
            "        Return an accurate floating point sum of values in the iterable.\n",
            "        Assumes IEEE-754 floating point arithmetic.\n",
            "    \n",
            "    gamma(...)\n",
            "        gamma(x)\n",
            "        \n",
            "        Gamma function at x.\n",
            "    \n",
            "    gcd(...)\n",
            "        gcd(x, y) -> int\n",
            "        greatest common divisor of x and y\n",
            "    \n",
            "    hypot(...)\n",
            "        hypot(x, y)\n",
            "        \n",
            "        Return the Euclidean distance, sqrt(x*x + y*y).\n",
            "    \n",
            "    isclose(...)\n",
            "        isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) -> bool\n",
            "        \n",
            "        Determine whether two floating point numbers are close in value.\n",
            "        \n",
            "           rel_tol\n",
            "               maximum difference for being considered \"close\", relative to the\n",
            "               magnitude of the input values\n",
            "            abs_tol\n",
            "               maximum difference for being considered \"close\", regardless of the\n",
            "               magnitude of the input values\n",
            "        \n",
            "        Return True if a is close in value to b, and False otherwise.\n",
            "        \n",
            "        For the values to be considered close, the difference between them\n",
            "        must be smaller than at least one of the tolerances.\n",
            "        \n",
            "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
            "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
            "        only close to themselves.\n",
            "    \n",
            "    isfinite(...)\n",
            "        isfinite(x) -> bool\n",
            "        \n",
            "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
            "    \n",
            "    isinf(...)\n",
            "        isinf(x) -> bool\n",
            "        \n",
            "        Return True if x is a positive or negative infinity, and False otherwise.\n",
            "    \n",
            "    isnan(...)\n",
            "        isnan(x) -> bool\n",
            "        \n",
            "        Return True if x is a NaN (not a number), and False otherwise.\n",
            "    \n",
            "    ldexp(...)\n",
            "        ldexp(x, i)\n",
            "        \n",
            "        Return x * (2**i).\n",
            "    \n",
            "    lgamma(...)\n",
            "        lgamma(x)\n",
            "        \n",
            "        Natural logarithm of absolute value of Gamma function at x.\n",
            "    \n",
            "    log(...)\n",
            "        log(x[, base])\n",
            "        \n",
            "        Return the logarithm of x to the given base.\n",
            "        If the base not specified, returns the natural logarithm (base e) of x.\n",
            "    \n",
            "    log10(...)\n",
            "        log10(x)\n",
            "        \n",
            "        Return the base 10 logarithm of x.\n",
            "    \n",
            "    log1p(...)\n",
            "        log1p(x)\n",
            "        \n",
            "        Return the natural logarithm of 1+x (base e).\n",
            "        The result is computed in a way which is accurate for x near zero.\n",
            "    \n",
            "    log2(...)\n",
            "        log2(x)\n",
            "        \n",
            "        Return the base 2 logarithm of x.\n",
            "    \n",
            "    modf(...)\n",
            "        modf(x)\n",
            "        \n",
            "        Return the fractional and integer parts of x.  Both results carry the sign\n",
            "        of x and are floats.\n",
            "    \n",
            "    pow(...)\n",
            "        pow(x, y)\n",
            "        \n",
            "        Return x**y (x to the power of y).\n",
            "    \n",
            "    radians(...)\n",
            "        radians(x)\n",
            "        \n",
            "        Convert angle x from degrees to radians.\n",
            "    \n",
            "    sin(...)\n",
            "        sin(x)\n",
            "        \n",
            "        Return the sine of x (measured in radians).\n",
            "    \n",
            "    sinh(...)\n",
            "        sinh(x)\n",
            "        \n",
            "        Return the hyperbolic sine of x.\n",
            "    \n",
            "    sqrt(...)\n",
            "        sqrt(x)\n",
            "        \n",
            "        Return the square root of x.\n",
            "    \n",
            "    tan(...)\n",
            "        tan(x)\n",
            "        \n",
            "        Return the tangent of x (measured in radians).\n",
            "    \n",
            "    tanh(...)\n",
            "        tanh(x)\n",
            "        \n",
            "        Return the hyperbolic tangent of x.\n",
            "    \n",
            "    trunc(...)\n",
            "        trunc(x:Real) -> Integral\n",
            "        \n",
            "        Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.\n",
            "\n",
            "DATA\n",
            "    e = 2.718281828459045\n",
            "    inf = inf\n",
            "    nan = nan\n",
            "    pi = 3.141592653589793\n",
            "    tau = 6.283185307179586\n",
            "\n",
            "FILE\n",
            "    (built-in)\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PjSRA-0n2-D1",
        "colab_type": "text"
      },
      "source": [
        "# Accessing Attributes/Methods of any object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XoJ9Dgl7qo1H",
        "colab_type": "code",
        "outputId": "6f4944e1-8136-4f7d-ab0c-e17eba1e1d4d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 924
        }
      },
      "source": [
        "import math\n",
        "#To know methods inside a module kindly make use of 'dir'\n",
        "dir(math)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['__doc__',\n",
              " '__loader__',\n",
              " '__name__',\n",
              " '__package__',\n",
              " '__spec__',\n",
              " 'acos',\n",
              " 'acosh',\n",
              " 'asin',\n",
              " 'asinh',\n",
              " 'atan',\n",
              " 'atan2',\n",
              " 'atanh',\n",
              " 'ceil',\n",
              " 'copysign',\n",
              " 'cos',\n",
              " 'cosh',\n",
              " 'degrees',\n",
              " 'e',\n",
              " 'erf',\n",
              " 'erfc',\n",
              " 'exp',\n",
              " 'expm1',\n",
              " 'fabs',\n",
              " 'factorial',\n",
              " 'floor',\n",
              " 'fmod',\n",
              " 'frexp',\n",
              " 'fsum',\n",
              " 'gamma',\n",
              " 'gcd',\n",
              " 'hypot',\n",
              " 'inf',\n",
              " 'isclose',\n",
              " 'isfinite',\n",
              " 'isinf',\n",
              " 'isnan',\n",
              " 'ldexp',\n",
              " 'lgamma',\n",
              " 'log',\n",
              " 'log10',\n",
              " 'log1p',\n",
              " 'log2',\n",
              " 'modf',\n",
              " 'nan',\n",
              " 'pi',\n",
              " 'pow',\n",
              " 'radians',\n",
              " 'sin',\n",
              " 'sinh',\n",
              " 'sqrt',\n",
              " 'tan',\n",
              " 'tanh',\n",
              " 'tau',\n",
              " 'trunc']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1uQSdo4lVoRs",
        "colab_type": "text"
      },
      "source": [
        "# Basic Data types in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C3m7zsHi3T8U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The basic datatypes are str, int, float, list, set, dict. It is advised not to use them for naming a variable."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uoW14a9uyoIW",
        "colab_type": "code",
        "outputId": "44315bb8-bdbd-417c-f286-bf8319445faf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 134
        }
      },
      "source": [
        "string = 'Vishnu' + ' Thakral' #We can directly add strings in this manner\n",
        "integer = 5 \n",
        "floats = 5.1212\n",
        "lists = [1,3,5,5]\n",
        "list_of_tuples = [(1,3),(3,4,5),(5,4)]\n",
        "sets = set((1,2,3,3))\n",
        "dictionary = {'Mr.X':'Inventor','Profession':'Research','Location':'Earth'}\n",
        "boolean = True\n",
        "none_type = None\n",
        "\n",
        "print(string,type(string)) #type prints the type of the object it is called on.\n",
        "print(integer,type(integer))\n",
        "print(floats,type(floats))\n",
        "print(lists,type(lists))\n",
        "print(list_of_tuples,type(list_of_tuples))\n",
        "print(sets,type(sets))\n",
        "print(dictionary,type(dictionary))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Vishnu Thakral <class 'str'>\n",
            "5 <class 'int'>\n",
            "5.1212 <class 'float'>\n",
            "[1, 3, 5, 5] <class 'list'>\n",
            "[(1, 3), (3, 4, 5), (5, 4)] <class 'list'>\n",
            "{1, 2, 3} <class 'set'>\n",
            "{'Mr.X': 'Inventor', 'Profession': 'Research', 'Location': 'Earth'} <class 'dict'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yc7gM5E1VWQo",
        "colab_type": "text"
      },
      "source": [
        "# Commonly Used Operators and Assignment in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t1vWtFlpgbAh",
        "colab_type": "code",
        "outputId": "8d639dc8-6a80-449d-c337-d37942bbb5bd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 370
        }
      },
      "source": [
        "a = 10\n",
        "b = 10\n",
        "\n",
        "print('Add', a+b)  #Add\n",
        "print('Subtract', a-b)  # Subtract\n",
        "print('Divide', a/b)  #Divide  with return answer as floating point\n",
        "print('Multiply', a*b)  #Mul\n",
        "print('Floor Division',a//b) #Divide with integer return type\n",
        "print('Mod', a%b)  #Mod\n",
        "print('Power', a**b) #Pow\n",
        "\n",
        "#Bitwise operators\n",
        "print('XOR', a^b)  #XOR\n",
        "print('And', a & b) #\n",
        "print('Or', a | b) #OR\n",
        "print('Not', ~a)    #NOT\n",
        "print('Right shift', a >> 2) #right shift #divide by 2, 2 times\n",
        "print('Left shift', a << 3) #left shift OR multiply by 2, 3 times\n",
        "\n",
        "# Assignment Operator\n",
        "print('A before assignment operators', a)\n",
        "a += a\n",
        "print('After add', a)\n",
        "a -= b\n",
        "print('After sub', a)\n",
        "a *= b\n",
        "print('After mul', a)\n",
        "a /= b\n",
        "print('After div', a)\n",
        "\n",
        "print('a and b before swap are: ', a, b)\n",
        "a,b = b,a\n",
        "print('a and b after swap are: ', a, b)\n",
        "a = b = 0\n",
        "print('After final assignment: ', a, b)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Add 20\n",
            "Subtract 0\n",
            "Divide 1.0\n",
            "Multiply 100\n",
            "Floor Division 1\n",
            "Mod 0\n",
            "Power 10000000000\n",
            "XOR 0\n",
            "And 10\n",
            "Or 10\n",
            "Not -11\n",
            "Right shift 2\n",
            "Left shift 80\n",
            "A before assignment operators 10\n",
            "After add 20\n",
            "After sub 10\n",
            "After mul 100\n",
            "After div 10.0\n",
            "a and b before swap are:  10.0 10\n",
            "a and b after swap are:  10 10.0\n",
            "After final assignment:  0 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SE0w7MnVWfU3",
        "colab_type": "text"
      },
      "source": [
        "# Type Casting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FmT_aO6j3Abv",
        "colab_type": "code",
        "outputId": "25f76768-0947-4a0f-d893-e06a63ded7ca",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 302
        }
      },
      "source": [
        "#string (str) to int\n",
        "\n",
        "string = '10'\n",
        "print('int typecasted is: ', int(string))\n",
        "print()\n",
        "\n",
        "#string to float\n",
        "print('Float typecasted is: ',float(string))\n",
        "print()\n",
        "\n",
        "#string to list\n",
        "lists = list(string)\n",
        "print('Typecasted to list: ', lists)\n",
        "print()\n",
        "\n",
        "#list to string\n",
        "print('List to string', ''.join(lists))\n",
        "print()\n",
        "\n",
        "#int to string\n",
        "string = str(1) + '0'\n",
        "print('Int to string', string)\n",
        "print()\n",
        "\n",
        "#ascii value of alpha numeric characters\n",
        "print(chr(97))\n",
        "print()\n",
        "\n",
        "#string to ascii\n",
        "print(ord('a'))\n",
        "print()\n",
        "\n",
        "#set to list\n",
        "s = set((1,2,3,3,4,5))\n",
        "list_s = list(s)\n",
        "print(list_s)\n",
        "print()\n",
        "\n",
        "#tuple to list\n",
        "tuples = ((1,2),(1,'darshan'),(4,'Brooklyn'))\n",
        "list_tup = list(tuples)\n",
        "print(list_tup)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int typecasted is:  10\n",
            "\n",
            "Float typecasted is:  10.0\n",
            "\n",
            "Typecasted to list:  ['1', '0']\n",
            "\n",
            "List to string 10\n",
            "\n",
            "Int to string 10\n",
            "\n",
            "a\n",
            "\n",
            "97\n",
            "\n",
            "[1, 2, 3, 4, 5]\n",
            "\n",
            "[(1, 2), (1, 'darshan'), (4, 'Brooklyn')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3lgU0-MM0bkE",
        "colab_type": "text"
      },
      "source": [
        "# Basic Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UWZzu6CEzNCH",
        "colab_type": "code",
        "outputId": "117b1725-1e1b-47a7-c1f7-0872d7d5c137",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 353
        }
      },
      "source": [
        "import random\n",
        "\n",
        "#start and end paramaters\n",
        "print('Generating random range from start and end range inclusive ',end='')\n",
        "print(random.randint(5,10))\n",
        "\n",
        "print()\n",
        "print('Exploring built in methods of Math library')\n",
        "import math\n",
        "print('Inbuilt constant ',math.pi)\n",
        "print('Sqrt of 25 ',math.sqrt(25))\n",
        "print('Ceil value',math.ceil(10.56))\n",
        "print('Floor value',math.floor(5.3))\n",
        "\n",
        "print()\n",
        "import numpy as np\n",
        "print('Array of type ',type(np.array([[1,2,3],[4,5,6]])),'\\n')\n",
        "\n",
        "print('Working with Datetime')\n",
        "import datetime\n",
        "date = datetime.datetime.now()\n",
        "print(date)\n",
        "print(type(date))\n",
        "\n",
        "#import only specific classes from module\n",
        "\n",
        "print('\\nExploring DateTime module..')\n",
        "from datetime import date\n",
        "print (\"The represented date is : \",end=\"\") \n",
        "print (datetime.date(2019,4,1)) \n",
        "  \n",
        "# using today() to print present date \n",
        "print (\"Present date is : \",end=\"\") \n",
        "print (date.today()) \n",
        "print()\n",
        "\n",
        "print (\"The calculated date from seconds is : \",end='')\n",
        "print()\n",
        "\n",
        "print (date.fromtimestamp(3452435))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Generating random range from start and end range inclusive 10\n",
            "\n",
            "Exploring built in methods of Math library\n",
            "Inbuilt constant  3.141592653589793\n",
            "Sqrt of 25  5.0\n",
            "Ceil value 11\n",
            "Floor value 5\n",
            "\n",
            "Array of type  <class 'numpy.ndarray'> \n",
            "\n",
            "Working with Datetime\n",
            "2020-04-25 02:17:55.637208\n",
            "<class 'datetime.datetime'>\n",
            "\n",
            "Exploring DateTime module..\n",
            "The represented date is : 2019-04-01\n",
            "Present date is : 2020-04-25\n",
            "\n",
            "The calculated date from seconds is : \n",
            "1970-02-09\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ThigXZTWJDl",
        "colab_type": "text"
      },
      "source": [
        "# Lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kPnPku7saEJz",
        "colab_type": "code",
        "outputId": "df19337a-4668-42ef-b26f-ad2ac92daf59",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 151
        }
      },
      "source": [
        "#list Operator\n",
        "\n",
        "#initialize ways\n",
        "list_1 = list()\n",
        "print()\n",
        "\n",
        "#check the type of the variable\n",
        "print(type(list_1))\n",
        "print()\n",
        "\n",
        "list_num = [1,2,3,5]\n",
        "print(list_num)\n",
        "print()\n",
        "\n",
        "list_object = ['1','2',777,'%','delhi','^']\n",
        "print(list_object)\n",
        "print()\n",
        "\n",
        "#operator automatically computed when given inside list\n",
        "list_operator = [1*2,'art'+'ist',10//2]\n",
        "print(list_operator)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "<class 'list'>\n",
            "\n",
            "[1, 2, 3, 5]\n",
            "\n",
            "['1', '2', 777, '%', 'delhi', '^']\n",
            "\n",
            "[2, 'artist', 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T96I3O1Kbp4c",
        "colab_type": "text"
      },
      "source": [
        "# Access values from list\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wCQtIE75-YMU",
        "colab_type": "text"
      },
      "source": [
        "  Python allows negative indexing so if\n",
        "\n",
        "  forward indexing is    0    1   2    3\n",
        "\n",
        "Reverse Indexing is     -4   -3  -2   -1\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8e06bJFwbo97",
        "colab_type": "code",
        "outputId": "618d086d-e5c8-4c7c-e279-1f65f1b6d99a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 168
        }
      },
      "source": [
        "print(list_object)\n",
        "\n",
        "#Individual access\n",
        "list_object[0]\n",
        "print()\n",
        "\n",
        "#From start to end\n",
        "print(list_object[0:4])\n",
        "print()\n",
        "\n",
        "#Skipping in between\n",
        "print(list_object[0:6:3])\n",
        "print()\n",
        "\n",
        "#Negative indices:\n",
        "print(list_object[0:-2])\n",
        "print()\n",
        "\n",
        "#Negative ranges\n",
        "print(list_object[-4:-1])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['1', '2', 777, '%', 'delhi', '^']\n",
            "\n",
            "['1', '2', 777, '%']\n",
            "\n",
            "['1', '%']\n",
            "\n",
            "['1', '2', 777, '%']\n",
            "\n",
            "[777, '%', 'delhi']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R5tl5fTp024H",
        "colab_type": "text"
      },
      "source": [
        "# Modify List"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KhgVIv1fcook",
        "colab_type": "code",
        "outputId": "83c70bd0-5401-428e-c18a-d114544a390c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "#Make Changes in the list\n",
        "list_object.extend([0,1.2])\n",
        "print(list_object)\n",
        "print()\n",
        "\n",
        "#Make Range of values changes\n",
        "subset_items = [1,52,798,8]\n",
        "list_object[0:4] = subset_items\n",
        "print()\n",
        "\n",
        "#Skipping changes\n",
        "subset = ['2','45555','12']\n",
        "list_object[0:5:2] = subset\n",
        "print(list_object)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['1', '2', 777, '%', 'delhi', '^', 0, 1.2]\n",
            "\n",
            "\n",
            "['2', 52, '45555', 8, '12', '^', 0, 1.2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7yf-0xw_VK_P",
        "colab_type": "text"
      },
      "source": [
        "# Deleting values from List"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ipwDFQG1jPfg",
        "colab_type": "code",
        "outputId": "4405f98d-034c-4025-f8f0-bf540d332292",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "#Delete element\n",
        "list_object = [1,2,12,12,12,3,4,5,7]\n",
        "\n",
        "#Can be used as stack and queue\n",
        "list_object.pop(0) #queue\n",
        "list_object.pop() #stack\n",
        "list_object.pop(3) #index\n",
        "print(list_object)\n",
        "print()\n",
        "\n",
        "#Raise an error when removing values from present in the list or list is empty\n",
        "list_object.remove(12)\n",
        "print(list_object)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 12, 12, 3, 4, 5]\n",
            "\n",
            "[2, 12, 3, 4, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xJJ0xx2FepuL",
        "colab_type": "text"
      },
      "source": [
        "# Functionalities and Power of Lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IMm4exDceozD",
        "colab_type": "code",
        "outputId": "adb8ce11-e7ac-448d-d84e-8a0a2e2ac87e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        }
      },
      "source": [
        "list_basics = [0]*5\n",
        "print(list_basics)\n",
        "#Concatenating two lists:\n",
        "print()\n",
        "\n",
        "even_num = [0,2,4,6]\n",
        "odd_num = [1,3,5,7]\n",
        "\n",
        "sum_num = even_num + odd_num\n",
        "print('sum_num', sum_num)\n",
        "print()\n",
        "\n",
        "#Alternate way is using extend\n",
        "sum_num = []\n",
        "sum_num.extend(even_num)\n",
        "sum_num.append(odd_num)\n",
        "print('sum_num after extend and append', sum_num)\n",
        "print()\n",
        "\n",
        "#Using inbuilt functions\n",
        "print(len(sum_num))\n",
        "print(min(even_num))\n",
        "print(max(even_num))\n",
        "print(sum(even_num))\n",
        "\n",
        "import statistics\n",
        "print(statistics.median(even_num))\n",
        "\n",
        "#Use functions in the list and unpack the values\n",
        "# * - unpacking operator  \n",
        "\n",
        "new_list = [*range(10,20)]\n",
        "print(new_list)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 0, 0, 0, 0]\n",
            "\n",
            "sum_num [0, 2, 4, 6, 1, 3, 5, 7]\n",
            "\n",
            "sum_num after extend and append [0, 2, 4, 6, [1, 3, 5, 7]]\n",
            "\n",
            "5\n",
            "0\n",
            "6\n",
            "12\n",
            "3.0\n",
            "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ozjkG8ljjirD",
        "colab_type": "text"
      },
      "source": [
        "# Basic of 2D list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-lxSXeHQjqj0",
        "colab_type": "code",
        "outputId": "90c7ab80-f0fa-4fef-a0f0-28b8baaee051",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "list_2d = [[13,4,5,6],['a','b','c','d'],[1,2,3,4,5,6,7]]\n",
        "\n",
        "#Whole list at particular index\n",
        "print(list_2d[1])\n",
        "\n",
        "#Access all list after given index\n",
        "print(list_2d[1:])\n",
        "\n",
        "#Alternative\n",
        "print(list_2d[:][1:3])\n",
        "\n",
        "#Individual elements:\n",
        "print(list_2d[0][1])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['a', 'b', 'c', 'd']\n",
            "[['a', 'b', 'c', 'd'], [1, 2, 3, 4, 5, 6, 7]]\n",
            "[['a', 'b', 'c', 'd'], [1, 2, 3, 4, 5, 6, 7]]\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gsdTzMn7cdcd",
        "colab_type": "text"
      },
      "source": [
        "# For loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M90ZZ1eRlSRw",
        "colab_type": "code",
        "outputId": "3ee488a5-ac23-45cb-e5fa-38ae6eba151e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 538
        }
      },
      "source": [
        "#Print in single line\n",
        "for i in range(0,5):\n",
        "  print(i, end = ' ')\n",
        "\n",
        "#print()\n",
        "\n",
        "#custom range\n",
        "for i in range(1,0,-1):\n",
        "  print('Previous print pointer is still on the same single ',i,'\\n')\n",
        "\n",
        "#Step parameter added in range\n",
        "print('Step parameter addition')\n",
        "for i in range(10,2,-2):\n",
        "  print(i,end= ' ')\n",
        "\n",
        "#Use of reverse\n",
        "print('\\nReversed print Order')\n",
        "for i in reversed(range(4)):\n",
        "  print(i)\n",
        "\n",
        "#Unrolling any iterator for that matter\n",
        "print('\\nPrinting list values')\n",
        "sums = [1,1,3,5]\n",
        "for number in sums:\n",
        "  print(number)\n",
        "\n",
        "sum_num = []\n",
        "for i in range(10):\n",
        "  sum_num.append(i)\n",
        "print(sum_num)\n",
        "#One liner for loop\n",
        "print('\\nOne Linear For Loop')\n",
        "sum_upto_10 = [ i for i in range(11)]\n",
        "print(sum_upto_10)\n",
        "\n",
        "#One Linear Nested for loop\n",
        "print('\\nOne Linear Nested for loop Matrix Multiplication\\n')\n",
        "matrix_mul = []\n",
        "matrix_mul = [j*i for i in range(5) for j in range(5,10)]\n",
        "print('Matrix Looks like:',matrix_mul)\n",
        "\n",
        "print('\\n\\n#######Printing Matrix using Above Concepts of indicing########')\n",
        "start = 0\n",
        "end = 5\n",
        "for i in range(5):\n",
        "  print(matrix_mul[start:end])\n",
        "  start = end \n",
        "  end += 5"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 Previous print pointer is still on the same single  1 \n",
            "\n",
            "Step parameter addition\n",
            "10 8 6 4 \n",
            "Reversed print Order\n",
            "3\n",
            "2\n",
            "1\n",
            "0\n",
            "\n",
            "Printing list values\n",
            "1\n",
            "1\n",
            "3\n",
            "5\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "\n",
            "One Linear For Loop\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
            "\n",
            "One Linear Nested for loop Matrix Multiplication\n",
            "\n",
            "Matrix Looks like: [0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 15, 18, 21, 24, 27, 20, 24, 28, 32, 36]\n",
            "\n",
            "\n",
            "#######Printing Matrix using Above Concepts of indicing########\n",
            "[0, 0, 0, 0, 0]\n",
            "[5, 6, 7, 8, 9]\n",
            "[10, 12, 14, 16, 18]\n",
            "[15, 18, 21, 24, 27]\n",
            "[20, 24, 28, 32, 36]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MgjJOWFY1l6_",
        "colab_type": "text"
      },
      "source": [
        "# Defining functions of our own"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-qZiBOElYjs",
        "colab_type": "code",
        "outputId": "a2be297c-fc30-4c5c-b580-30497a1f58e6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        }
      },
      "source": [
        "#Fizz Buzz coding\n",
        "# To define a function use the def keyword followed by func name with attributes (if any) passed.\n",
        "\n",
        "def fizzBuzz():\n",
        "  '''\n",
        "  Given a range print Fizz if divisible by 3, Buzz if divisible by 5 else FizzBuzz if divisible by 3 and 5\n",
        "  '''\n",
        "  n = int(input('Enter a number '))\n",
        "  #Python way\n",
        "  count = 1\n",
        "  while (count <= n):\n",
        "    string = ''\n",
        "    if (count %3 == 0):\n",
        "      string = 'Fizz'\n",
        "    if(count % 5 == 0):\n",
        "      string += 'Buzz'\n",
        "    \n",
        "    print(count,string)\n",
        "    count +=1\n",
        "fizzBuzz()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter a number 5\n",
            "1 \n",
            "2 \n",
            "3 Fizz\n",
            "4 \n",
            "5 Buzz\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uo5lq1CBAfse",
        "colab_type": "code",
        "outputId": "269d5de2-ddf8-470d-e06a-6d97742da4c3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        }
      },
      "source": [
        "def fizzBuzz():\n",
        "  '''\n",
        "  Same function as above with more if else conditions.\n",
        "  '''\n",
        "  n = int(input('Enter a number '))\n",
        "  count = 1\n",
        "  while(count <= n):\n",
        "    if(count % 5 == 0 and count % 3 == 0):\n",
        "      print(count,'Fizz Buzz')\n",
        "    elif(count % 3 == 0):\n",
        "      print(count,'Fizz')\n",
        "    elif(count % 5 == 0):\n",
        "      print(count,'Buzz')\n",
        "    else:\n",
        "      print(count)\n",
        "    count +=1\n",
        "fizzBuzz()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter a number 5\n",
            "1\n",
            "2\n",
            "3 Fizz\n",
            "4\n",
            "5 Buzz\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hQxjykYq-cg0",
        "colab_type": "text"
      },
      "source": [
        "# Dictionary\n",
        "We use key and not index to reference elements in dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sAs5nW2w3jBJ",
        "colab_type": "code",
        "outputId": "a2a345d7-a0a4-412e-e22b-4789574b8dc7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        }
      },
      "source": [
        "#Creating an empty dictionary\n",
        "dict_ = {} # We defined dict_ and not dict \n",
        "#dict_ = {key:value,key:value} #Keys have to be in a set i.e they are to be unique\n",
        "string = 'iamdictionaryiteratemeandseethefun'\n",
        "\n",
        "for ch in string:\n",
        "  if(ch in dict_):\n",
        "    dict_[ch] +=1\n",
        "\n",
        "  else:\n",
        "    dict_[ch] = 1\n",
        "\n",
        "for k,v in dict_.items():\n",
        "  #pass\n",
        "  print(f'Character {k} and its count {v}')\n",
        "\n",
        "#if we try updating for a key that is present the original value will be overwritten"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Character i and its count 4\n",
            "Character a and its count 4\n",
            "Character m and its count 2\n",
            "Character d and its count 2\n",
            "Character c and its count 1\n",
            "Character t and its count 4\n",
            "Character o and its count 1\n",
            "Character n and its count 3\n",
            "Character r and its count 2\n",
            "Character y and its count 1\n",
            "Character e and its count 6\n",
            "Character s and its count 1\n",
            "Character h and its count 1\n",
            "Character f and its count 1\n",
            "Character u and its count 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cTRXkI6SDzqR",
        "colab_type": "code",
        "outputId": "deb99c2c-5891-458a-dba5-7b6f943dd16b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 229
        }
      },
      "source": [
        "#Print value for some key\n",
        "print(dict_['i'])\n",
        "print()\n",
        "\n",
        "#Avoid error like these\n",
        "#Error raised when key is not present in the dictionary\n",
        "dict_['g']"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "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-21-9b63751a525f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#Avoid error like these\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m#Error raised when key is not present in the dictionary\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mdict_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'g'\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: 'g'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P0R9uIDKEs5E",
        "colab_type": "code",
        "outputId": "6f14ad95-6388-479b-ac1a-7d88f9577bad",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#To keep the function running avoiding errors like above we can use try and except blocks\n",
        "try:\n",
        "  print(dict_['g'])\n",
        "except KeyError:\n",
        "  print('The key was not found, you may try again.')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The key was not found, you may try again.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rSGT2v_oW18g",
        "colab_type": "text"
      },
      "source": [
        "**Intuitive ways of creating custom dictionaries**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qtMPOWgj_Dv0",
        "colab_type": "code",
        "outputId": "4d6624b3-bd7a-47ef-eafc-287a9262073e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 134
        }
      },
      "source": [
        "from collections import defaultdict\n",
        "\n",
        "#Real world problem - [1,2] - Connection map from one city to another city\n",
        "#Derive a graph mapping all the connection of cities includes in edges list_of_list\n",
        "\n",
        "graph = defaultdict(list)\n",
        "edges = [[1,2],[3,4],[2,4],[4,6],[3,5],[6,2],[1,7],[7,4]]\n",
        "\n",
        "def addEdges(s,e):\n",
        "  graph[s].append(e)\n",
        "  graph[e].append(s)\n",
        "\n",
        "for u,v in edges:\n",
        "  addEdges(u,v)\n",
        "\n",
        "for k,v in graph.items():\n",
        "  print(f\"Node {k} it's children {v}\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Node 1 it's children [2, 7]\n",
            "Node 2 it's children [1, 4, 6]\n",
            "Node 3 it's children [4, 5]\n",
            "Node 4 it's children [3, 2, 6, 7]\n",
            "Node 6 it's children [4, 2]\n",
            "Node 5 it's children [3]\n",
            "Node 7 it's children [1, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G94YufFXWn-8",
        "colab_type": "text"
      },
      "source": [
        "**Fetching keys and values from dictionary**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dKE2K8Eo_7RI",
        "colab_type": "code",
        "outputId": "bf8b7c1a-f47d-40d9-acd3-108bcbc52b6b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 151
        }
      },
      "source": [
        "#get keys and values seperately\n",
        "\n",
        "keys = list(graph.keys())\n",
        "values = list(graph.values())\n",
        "\n",
        "print(keys)\n",
        "print('-------------')\n",
        "print(values)\n",
        "\n",
        "print('\\n\\nIndividual access for given key')\n",
        "#Get children for 7th node\n",
        "print(graph[7])\n",
        "\n",
        "#error raised when key not found in dict\n",
        "\n",
        "#In this case it's outputting the answer. Think why?\n",
        "print(graph[19])\n",
        "\n",
        "#Why keys cannot be of list dataype in dictionary?"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 6, 5, 7]\n",
            "-------------\n",
            "[[2, 7], [1, 4, 6], [4, 5], [3, 2, 6, 7], [4, 2], [3], [1, 4]]\n",
            "\n",
            "\n",
            "Individual access for given key\n",
            "[1, 4]\n",
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3-3CSuSvCCd8",
        "colab_type": "text"
      },
      "source": [
        "# Sorting and Lambda Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sv3JKa5tCCS7",
        "colab_type": "code",
        "outputId": "8b8c22cd-c0dd-4102-d37b-f1e5acc6750a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 151
        }
      },
      "source": [
        "#Sorting a list\n",
        "\n",
        "#For sorting the dataype should be of same type\n",
        "list_ = ['a','3232','21332','bsaa','87']\n",
        "print('Ascending order ',list_)\n",
        "\n",
        "#Insights of this sorting\n",
        "result = []\n",
        "for i in list_:\n",
        "  sum_ = 0\n",
        "  for j in i:\n",
        "    sum_ = ord(j)\n",
        "    break\n",
        "  result.append(sum_)\n",
        "\n",
        "#It checks the first character of a string if there is a match with other string then it goes \n",
        "print('Before sorting')\n",
        "print(list_)\n",
        "print(result)\n",
        "\n",
        "print('---------------')\n",
        "print('After sorting')\n",
        "list_.sort()\n",
        "result.sort()\n",
        "print(list_)\n",
        "print(result)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ascending order  ['a', '3232', '21332', 'bsaa', '87']\n",
            "Before sorting\n",
            "['a', '3232', '21332', 'bsaa', '87']\n",
            "[97, 51, 50, 98, 56]\n",
            "---------------\n",
            "After sorting\n",
            "['21332', '3232', '87', 'a', 'bsaa']\n",
            "[50, 51, 56, 97, 98]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "McK2Xog8MDut",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "#Sorted vs Sort\n",
        "\n",
        "The primary difference between the list sort() function and the sorted() function.\n",
        "\n",
        "sort() function will modify the list it is called on.The function modifies/sorts the list in-place and has no return value.\n",
        "\n",
        "The sorted() function will create a new list containing a sorted version of the list it is given."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nkz4NsxUCdRg",
        "colab_type": "code",
        "outputId": "d3ff781b-2697-45b2-e483-e15855a081b7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "a = [1,3,2]\n",
        "print('a before any sort: ', a)\n",
        "b = sorted(a)\n",
        "print('a after sorted: ',a)\n",
        "print('b: ', b)\n",
        "a.sort()\n",
        "print('a after sort(): ', a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a before any sort:  [1, 3, 2]\n",
            "a after sorted:  [1, 3, 2]\n",
            "b:  [1, 2, 3]\n",
            "a after sort():  [1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JLhEaZRrGnkx",
        "colab_type": "text"
      },
      "source": [
        "#Lambda functions and dictionary insights with sorting functions\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3eSfydqCMCYS",
        "colab_type": "code",
        "outputId": "4f79b996-0fad-492e-b66a-754861f70ff1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        }
      },
      "source": [
        "#Lambda function \n",
        "\n",
        "print('Lambda Function')\n",
        "x = lambda a, b, c : a + b + c\n",
        "print(x(5, 6, 2))\n",
        "\n",
        "#Can be interpreted as normal functions in python\n",
        "def sumFunc(a,b,c):\n",
        "  return a+b+c\n",
        "sumFunc(5,6,2)\n",
        "\n",
        "#One way of Initialzing Dictionary keys as Ages and value as name of Person\n",
        "#Find drawback of such keys?\n",
        "#Ans person could have same age and hence the previous values will be replaced with new person name.\n",
        "\n",
        "dictonary = {67:\"Rahul\",23:\"Darsh\",12:\"Dhaval\",45:\"Manish\",11:\"Dipam\",99:\"Darshan\"}\n",
        "\n",
        "#To sort values based on either key or values in the dictionary and supply order of sort in reverse parameter\n",
        "tuples = sorted(dictonary.items(), key = lambda x: x[0], reverse = False)\n",
        "\n",
        "#Note just in list tuple cannot be unpacked, it needs to be accessed index wise\n",
        "#Print the sorted elements\n",
        "print('Sorted on keys')\n",
        "for elements in tuples:\n",
        "    print(elements[0],\"::\",elements[1])\n",
        "\n",
        "\n",
        "#Sort First on values and then keys, Interesting\n",
        "tuples  = sorted(dictonary.items(),key = lambda x:(x[1],x[0]), reverse=False)\n",
        "print('Sorted on first values and then keys\\n')\n",
        "for elements in tuples:\n",
        "    print(elements[0],\"::\",elements[1])\n",
        "\n",
        "\n",
        "#Ordered Dict sorts the dictionary but aligns the result as per the same order when it arrived\n",
        "from collections import OrderedDict\n",
        "d = OrderedDict()\n",
        "d = {67:\"Rahul\",23:\"Darshan\",12:\"Dhaval\",45:\"Rahul\",11:\"Dipam\",99:\"Darshan\",27:\"Vishnu\"}\n",
        "tup = sorted(d.items(), key = lambda x: x[1], reverse = False)\n",
        "\n",
        "print('\\nPreserve the order of insertion')\n",
        "for elements in tup:\n",
        "    print(elements[0],\"::\",elements[1])\n",
        "\n",
        "#sorted and sort can be applied on list,tuples, sets etc\n",
        "print('\\nSorting on List')\n",
        "lst = [12,11,1,23,43,87,98]\n",
        "lst = sorted(lst, reverse = True)\n",
        "print(lst)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Lambda Function\n",
            "13\n",
            "Sorted on keys\n",
            "11 :: Dipam\n",
            "12 :: Dhaval\n",
            "23 :: Darsh\n",
            "45 :: Manish\n",
            "67 :: Rahul\n",
            "99 :: Darshan\n",
            "Sorted on first values and then keys\n",
            "\n",
            "23 :: Darsh\n",
            "99 :: Darshan\n",
            "12 :: Dhaval\n",
            "11 :: Dipam\n",
            "45 :: Manish\n",
            "67 :: Rahul\n",
            "\n",
            "Preserve the order of insertion\n",
            "23 :: Darshan\n",
            "99 :: Darshan\n",
            "12 :: Dhaval\n",
            "11 :: Dipam\n",
            "67 :: Rahul\n",
            "45 :: Rahul\n",
            "27 :: Vishnu\n",
            "\n",
            "Sorting on List\n",
            "[98, 87, 43, 23, 12, 11, 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gg4ff4pPNPkr",
        "colab_type": "text"
      },
      "source": [
        "# Counters alternative for Dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "64x6Us9eCnV0",
        "colab_type": "code",
        "outputId": "edb96a06-9625-448d-ce44-830ca70706e9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 168
        }
      },
      "source": [
        " from collections import Counter\n",
        "color = ['blue','blue','red','yellow','green','red']\n",
        "z = Counter(color)\n",
        "print('Type ',type(z))\n",
        "print(z)\n",
        "\n",
        "#Can be initialized like this also\n",
        "coun = Counter(a=1, b=2, c=3, d=120, e=1, f=219)\n",
        "print('\\nMost frequent occuring letters using Counters')\n",
        "for letter,count in coun.most_common(3):\n",
        "    print('%s %d' %(letter,count))\n",
        "\n",
        "print('Convert counters to List')\n",
        "coun = Counter(a=1, b=2, c=3) \n",
        "print(list(coun.elements())) "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Type  <class 'collections.Counter'>\n",
            "Counter({'blue': 2, 'red': 2, 'yellow': 1, 'green': 1})\n",
            "\n",
            "Most frequent occuring letters using Counters\n",
            "f 219\n",
            "d 120\n",
            "c 3\n",
            "Convert counters to List\n",
            "['a', 'b', 'b', 'c', 'c', 'c']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fvu913NcYtVX",
        "colab_type": "text"
      },
      "source": [
        "**Tasks for coming weeks**\n",
        "\n",
        "*   Explore map,filter,apply data\n",
        "*   Make yourself Familiar with imports like os,time,datetime,math.\n",
        "*   Assignment will be released soon, involves heavy use of dictionary and mentioned imports.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H2-BYwNuSOBF",
        "colab_type": "text"
      },
      "source": [
        "# Congratulations on making till the end!"
      ]
    }
  ]
}