Advanced_Python_Bootcamp.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Adv-Python_Bootcamp.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "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/ai-vithink/Python-Beginner-Resources/blob/master/Advanced_Python_Bootcamp.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cQmMshL4QhqR",
        "colab_type": "text"
      },
      "source": [
        " ![alt text](https://ai-vithink.github.io/img/VIThink_Logo.png)\n",
        " ## Hey Peeps Welcome to the Advanced Python Workshop\n",
        "Let's get you guys started !!! "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aOMe5RXGUJQp",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://i.redd.it/y6b074nj41g31.png)\n",
        "\n",
        "# Life Pro Tip : If you change the variable name it’s ok!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vg0i87iZQoEu",
        "colab_type": "text"
      },
      "source": [
        "### Warmup Exercises "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AIasZthdBKbl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(1,8,2):\n",
        "  print(i)\n",
        "\n",
        "#Docs: range(start, stop, step)\n",
        "#Hint: The Range Funtion Iterates from Index start to stop-1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iB7nMWmOBPxC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(5,0,-1):\n",
        "  print(i)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g4UOYhiJQyT_",
        "colab_type": "text"
      },
      "source": [
        "### Sad part is we cant multiplicate/divide the i in for loop as in C++ \n",
        "### but we've got while to the rescue "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6c2NXsF0SP2U",
        "colab_type": "text"
      },
      "source": [
        "## Quick Refresher on difference between while and do while loops we covered in last workshop :\n",
        "![alt text](https://preview.redd.it/feuuoxk4w7g31.jpg?width=640&crop=smart&auto=webp&s=79c31767d969be393045ab3238b3822fd10e8569)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EerVdsXeByWv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "i = 2\n",
        "while (i<=10):\n",
        "  print(i)\n",
        "  i*=2\n",
        " "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U6yLd0URG5VY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "i = 10\n",
        "while(i>=1):\n",
        "  print(int(i))\n",
        "  i/=2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jw8idj6gH_xQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 2 Unique ways to iterate over a container \n",
        "array = [1,2,3,4,5]\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8VvWnE_QJ65X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# first way : indexed based iteration\n",
        "for i in range(len(array)):\n",
        "  print(array[i])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S1wmR6odKC4B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# second way ... for - in\n",
        "for i in array:\n",
        "  print(i)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nEufmjy7RSax",
        "colab_type": "text"
      },
      "source": [
        "## Lists and Dictionary Comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oNR0ommnp5bj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Basic Example\n",
        "\n",
        "s = [i for i in range(5)]\n",
        "s\n",
        "\n",
        "\"\"\" This is similar to writing the following code to make this array\n",
        "s=[]\n",
        "for i in range(5):\n",
        "  s.append(i)\n",
        "\"\"\"\n",
        "s\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jiTYo_QsLKMY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Lets Move to 2 way list comprehension\n",
        "\n",
        "m = [i*j for i in range(1,5) for j in range(1,5) if i!=j]\n",
        "m"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5OVxwAH3LSvK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Similarily for ditionaries ....\n",
        "\n",
        "d = {i:i+3 for i in range(5) for j in range(5)}\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jf_WvcXlLl5x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = {i:str(i) for i in range(10)}\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rK13Axx5WVUA",
        "colab_type": "text"
      },
      "source": [
        "# So Now as you know some beginners tricks .... \n",
        "# Lets get you started with basic data structures in Python \n",
        "# as they do not take time...\n",
        "\n",
        "# We will discuss Lists , Dictionaries , Set and Tuples \n",
        "\n",
        "# We are not discussing other general data structures which you might encounter in CSE1001 course as they are less relevant for Machine Learning\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xJUetNE3TMl5",
        "colab_type": "text"
      },
      "source": [
        "# Before we begin Data Structures ...Answering the question no one asked...\n",
        "##  Q. Is there a life after a Data Structure course ? \n",
        "![alt text](https://i.redd.it/yhgirjt5fqez.jpg)\n",
        "\n",
        "# Don't worry about it if you don't get understand it fully now."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xHD8ZEg3RhCq",
        "colab_type": "text"
      },
      "source": [
        "## Lists \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A2aWJrgZMl3_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Thats how you create an empty list\n",
        "Lists = []\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zcs8Cr1SMvED",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Thats how you put stuff in it :\n",
        "\n",
        "# You can put in anything .... almost anything ;)\n",
        "\n",
        "Lists.append(\"Kunal\") # Like String\n",
        "Lists.append(2) # Like Integer\n",
        "Lists.append(4.60) # A float\n",
        "Lists.append([1,2,3,4]) # Another List\n",
        "\n",
        "# Not Done Yet ... Put in a dictionary ... see how it goes :)\n",
        "\n",
        "Lists.append({1:\"k\",2:\"u\",3:\"n\",4:\"a\",5:\"l\"})\n",
        "\n",
        "\n",
        "# Lets see how is everyting inside\n",
        "print(Lists)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hlmpUDD0OCz5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Wanna remove something .. ?\n",
        "copy = Lists.copy()\n",
        "\n",
        "# last element\n",
        "copy.pop()\n",
        "\n",
        "#pop() will remove the last element in the list by default\n",
        "\n",
        "print(copy)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R2FoDnEpWHc1",
        "colab_type": "text"
      },
      "source": [
        "# Getting Errors ? Any Doubts ?\n",
        "![alt text](https://preview.redd.it/uowuilghb2g31.jpg?width=640&crop=smart&auto=webp&s=f7733d646f197ce1f23d1a505f1841d96c68baca)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cRr1kswwOdfB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# delete at a certain index\n",
        "copy = Lists.copy()\n",
        "\n",
        "copy.pop(2)\n",
        "\n",
        "print(copy)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2eVkAW_2PKKm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# similarily u can delete by index using del \n",
        "\n",
        "a = [1,2,3,4]\n",
        "del a[2]\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4aAysz8NPU7O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# u can also delete element by value \n",
        "a = [1,2,3,4,5,6,7]\n",
        "a.remove(5)\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Loz7TQbgPeOh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4R3Lnd9fRIoL",
        "colab_type": "text"
      },
      "source": [
        "## Dictionary \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l_gDMa6fQfWQ",
        "colab_type": "text"
      },
      "source": [
        "Dictionary are basically *tables*  that hold \"key-value\" pairs .... They can be too useful  . We often need them in ML while creating / storing data "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vBYKZ4k-STDA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Lets use something we learned\n",
        "d = {i:str(i*\"K\") for i in range(5)}\n",
        "d "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FnGWVpgESf7v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# accessing value via key \n",
        "print(d[1])\n",
        "\n",
        "print(d[2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qGr3LMaWSo5X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# adding a key-value entry \n",
        "d[5] = \"KUNAL\"\n",
        "d.update({6:\"SAHNI\"})\n",
        "d\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OoxJNShwS6dJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "deleting an entry \n",
        "del d[5]\n",
        "d.pop(6) # key-based"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MTmM8IFQTkcq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# get the key , values separately \n",
        "keys = d.keys()\n",
        "values = d.values()\n",
        "items = d.items()\n",
        "\n",
        "print(keys,\"\\n\",values,\"\\n\",items)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E1s6cUvmTlFh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Clearing the dictionary \n",
        "copy = d.copy()\n",
        "print(copy)\n",
        "copy.clear()\n",
        "print(copy)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uc87M30dU43A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Is dictionary self sorting ?\n",
        "d.update({-1:\"O\"})\n",
        "d\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qiw7QgnwX_Hw",
        "colab_type": "text"
      },
      "source": [
        "# Checkpoint. Let us know if you have any doubts.\n",
        "## The 5 stages of hel- I mean being a programmer\n",
        "![alt text](https://preview.redd.it/y4n56waihpf31.jpg?width=640&crop=smart&auto=webp&s=8f6506f4c54478699d4289280095dac8335f3b7e)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "msje_yYlVdHK",
        "colab_type": "text"
      },
      "source": [
        "## Sets and Tuples\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cCB7vnwTWwtn",
        "colab_type": "text"
      },
      "source": [
        "A tuple is a sequence of immutable Python objects. Tuples are just like lists with the exception that tuples cannot be changed once declared. Tuples are usually faster than lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RRgPG056VjFy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tup = (1, \"a\", \"string\", 1+2) \n",
        "print(tup) \n",
        "print(tup[1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XQ0XJDXFXBst",
        "colab_type": "text"
      },
      "source": [
        "Because sets cannot have multiple occurrences of the same element, it makes sets highly useful to efficiently remove duplicate values from a list or tuple and to perform common math operations like unions and intersections."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CLrgdi94XDS7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# initializing an empty set \n",
        "empty = set()\n",
        "empty"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "woIxHEdvXMiQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# initializing with values \n",
        "\n",
        "one = set([1,2,3,4])\n",
        "two = set([5,6,7,8])\n",
        "\n",
        "# another way \n",
        "three = {9,10,11,12}\n",
        "\n",
        "print(one , \" \" ,two,\" \", three)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eEzQRiLPXYuZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# add and delete values \n",
        "one.add(20)\n",
        "one.remove(1)\n",
        "print(one)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "95MTLQDdX37R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IhUNnGIoYQ6o",
        "colab_type": "text"
      },
      "source": [
        "### Set Operations , Set comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kGUIiXXMYS5P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "set1 = {1,2,3,4,5}\n",
        "set2 = {4,5,6,7,8}\n",
        "\n",
        "print(set1.union(set2))\n",
        "\n",
        "print(set1.intersection(set2))\n",
        "\n",
        "print(set1.symmetric_difference(set2))\n",
        "\n",
        "print(set1.difference(set2))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "etTihNBGZaKj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "setx = {16,20,30}\n",
        "# These sets have elements in common so it would return False\n",
        "print(set1.isdisjoint(set2))\n",
        "\n",
        "# These sets have no elements in common so it would return True\n",
        "print(set1.isdisjoint(setx))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-ajO0q8Yksx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Set comprehensions\n",
        "set3 = {i*3 for i in range(1,10)}\n",
        "set3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WDqM5CiPY4r7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# check for subsets\n",
        "a = {1,2,3,4,5}\n",
        "b = {4,5}\n",
        "b.issubset(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kb-e1JwWaCIv",
        "colab_type": "text"
      },
      "source": [
        "## Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ow8nnuIfgNbB",
        "colab_type": "text"
      },
      "source": [
        "### Declaration and Initialisation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wQtYZvWogUja",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Lets create a shelf where we will keep our books\n",
        "\n",
        "shelf = { i : [] for i in \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"}\n",
        "\n",
        "class Book:\n",
        "  \n",
        "  def __init__(self,name,author,publisher):\n",
        "    self.name = name\n",
        "    self.author = author\n",
        "    self.publisher = publisher \n",
        "    self.shelf_key = name[0].upper()\n",
        "    \n",
        "   # method to add book in Shelf \n",
        "  \n",
        "  def add(self,shelf):\n",
        "    \n",
        "    entry = {\n",
        "        \"name\" : self.name,\n",
        "        \"author\": self.author,\n",
        "        \"publisher\":self.publisher\n",
        "    }\n",
        "    \n",
        "    \n",
        "    # check first \n",
        "    if entry not in shelf[self.shelf_key] : \n",
        "      shelf[self.shelf_key].append(entry)\n",
        "    \n",
        "    \n",
        "    return shelf[self.shelf_key]\n",
        "  \n",
        "  \n",
        "  # method to remove a book from shelf \n",
        "  def remove(self,shelf):\n",
        "    \n",
        "    entry = {\n",
        "        \"name\" : self.name,\n",
        "        \"author\": self.author,\n",
        "        \"publisher\":self.publisher\n",
        "    }\n",
        "    \n",
        "    \n",
        "    # check first \n",
        "    if entry in shelf[self.shelf_key] :\n",
        "      shelf[self.shelf_key].remove(entry)\n",
        "      \n",
        "      \n",
        "     \n",
        "    return shelf[self.shelf_key]\n",
        " "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yutJpeMYjTlf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Lets test our Book class and shelf \n",
        "\n",
        "print(shelf)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vBe1rQ6ajcxF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Now lets add our first Book \n",
        "book_one = Book(name = \"Animal Farm\",author = \"George Orwell\" ,publisher = \"NAL\")\n",
        "\n",
        "# Now lets add this to the shelf\n",
        "book_one.add(shelf)\n",
        "\n",
        "print(shelf)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CRtNJGrdkQW1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Wow that was successfull , \n",
        "# Lets add a few more books\n",
        "\n",
        "book_two = Book(\"At Grave's End\" , \"Jeaniene Frost\" , \"Avon\")\n",
        "\n",
        "book_three = Book(\"Harry Potter Part1\", \"J.K. Rowling\",\"Penguin\")\n",
        "\n",
        "book_two.add(shelf)\n",
        "book_three.add(shelf)\n",
        "\n",
        "\n",
        "print(shelf)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NC9GgugvlVWj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Successfull again now lets try our removing from shelf method \n",
        "book_one.remove(shelf)\n",
        "\n",
        "print(shelf)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0bBVgm36lh6q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fLIskVXKloHr",
        "colab_type": "text"
      },
      "source": [
        "##  Wow , that felt like really cool stuff. Isn't it ?\n",
        "## Checkpoint. Let us know if you have any queries.\n",
        "## Here's another wholesome meme for all the aspiring developers here today : \n",
        "![alt text](https://external-preview.redd.it/-mrfiC65NnzTVhFxlsQI10szQx5HY80_8Fn110Yvh8M.jpg?auto=webp&s=3bd33a554143c5f95f2ddb2bc1cd8150d7400444)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CTbV5zMJlnGB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C-lyenpIl79B",
        "colab_type": "text"
      },
      "source": [
        "## Now some real quick built-in algorithms"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NtIcW2T5l_3h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Wanna sort a list :\n",
        "\n",
        "lis = [90,12,134,23,1,11,5]\n",
        "sorted(lis)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_H_bYt4GmLQt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Reverse a list \n",
        "print(*reversed(lis))\n",
        "\n",
        "# indexed based reversal \n",
        "print(lis[::-1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y2aYUyzZmaIs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "string = \"abcccddeeeff\"\n",
        "\n",
        "# count number of instances of character\n",
        "for i in set(string):\n",
        "  print(i+\" occurs : \"+str(string.count(i)) +\" times \")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dS63tSubnhqg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# remove duplicates from list \n",
        "arr = [1,2,3,4,5,5,6,6,7,1]\n",
        "\n",
        "print(list(set(arr)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8eX0lfGBoDK0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# convert a number to binary \n",
        "\n",
        "print(bin(2)[2:])\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y8HjATgdoOnI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# math library \n",
        "\n",
        "from math import sqrt , log , sin , cos , tan\n",
        "\n",
        "print(sqrt(4))\n",
        "print(log(16,4))\n",
        "print(sin(90))\n",
        "print(cos(90))\n",
        "print(tan(45))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JgnwuoQ_oVBt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# convert char to ascii number and vice versa\n",
        "\n",
        "print(ord(\"a\"))\n",
        "\n",
        "print(chr(97))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tdo3anCApRPv",
        "colab_type": "text"
      },
      "source": [
        "## Thats all for today folks! We are sure that this stuff will help you in your adventure in Python !!\n",
        "\n",
        "## Topics we will be covering in  upcoming workshops :\n",
        "\n",
        "###  **1. Data Visualisation - Matplotlib, Seaborn, Plotly etc.**\n",
        "###   **2. Exploratory Data Analysis**\n",
        "###   **3. ML Algorithms - Linear and Logistic Regression, KNN, Decision Trees, SVM,Random Forests etc.**\n",
        "###   **4. Bias Variance Trade off**\n",
        "### **5. Git, Linux and much more..!**\n",
        "\n",
        "**PS: You can also let us know through feedback forms and our instagram handle if you guys want workshops on any topics relevant to machine learning and data science.**\n",
        "\n",
        "Content which we will be covering in future workshops is already available on this link in form of Jupyter Notebooks : \n",
        "\n",
        "**https://github.com/AnmolTomer/ml_bootcamp_udemy**\n",
        "\n",
        "# Link for feedback form : http://tiny.cc/python-advanced\n",
        "# Feedback QR Code\n",
        "![alt text](https://i.imgur.com/HIe3C7o.png)"
      ]
    }
  ]
}