Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning a language is easy \n",
    "When ever you start with a new language , focus on few things in the below order.\n",
    "1. Operators and Data Types\n",
    "2. Conditional statements - ifelse, switch, case\n",
    "3. Loops - while, for\n",
    "4. Data Structures - Arrays, List, Dict, etc\n",
    "5. Define function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are containers to store data values\n",
    "\n",
    "A variable can have a short name (like x and y) or a more descriptive name (age, carname, total_volume). Rules for Python variables:\n",
    "1. A variable name must start with a letter or the underscore character\n",
    "2. A variable name cannot start with a number\n",
    "3. A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )\n",
    "4. Variable names are case-sensitive (age, Age and AGE are three different variables)\n",
    "\n",
    "\n",
    "#### Assigning multiple values\n",
    "\n",
    "Many values to multiple variables\n",
    "x,y,z = \"Python\",\"Introduction\",\"Batch90\"\n",
    "\n",
    "One value to multiple variables\n",
    "x=y=z = \"New Programming\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create 3 variables a,b,c and assign the values \"NMIMS\",\"Semester2\",\"Batch2\"\n",
    " \n",
    "# Method 1\n",
    "\n",
    "a = \"NMIMS\"\n",
    "b = \"Quarter 2\"\n",
    "c = \"Batch 2\"\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NMIMS'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Method 2\n",
    "\n",
    "a,b,c = \"NMIMS\",\"Quarter 2\",\"Batch 2\"\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Types\n",
    "In any programming language Data types are very important. A variable can store data of different types and different types can do different things. \n",
    "\n",
    "Below are built in data types for python programming language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"\"><div class=\"markdown-container-div Markdown__MarkdownContainerDiv-sc-1j2yuel-5 hwDRqT\" height=\"auto\"><div class=\"markdownViewer Markdown__Viewer-sc-1j2yuel-1 gvyjDX\" role=\"none\"><h2>Variations of data types</h2>\n",
    "<p>There are two kinds of data types, both of which are​ further divided into sub-types:</p>\n",
    "<ul>\n",
    "<li>\n",
    "<p><strong>Primitive data types:</strong> Data types which are pre-defined and supported by the programming language.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p><strong>Non-primitive data types:</strong> Data types which are derived from the primitive data types and offer increased functionality.\n",
    "​​</p>\n",
    "</li>\n",
    "</ul>\n",
    "</div></div></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Basic tips**\n",
    "---\n",
    "**Mathematical operations (+, -, *, /, %)** can be used just like any programming language\n",
    "\n",
    "**#** can be used for comments. Using this ahead of line with signal the compiler to not execute the line as a command\n",
    "\n",
    "**print()** will print the value stored in the variable. You can also give multiple arguments to the print function seperated by commas.\n",
    "\n",
    "**type()** will print the class of the variable\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style=\"text-align: left;\"><span lang=\"en-PK\"><b>Primitve Data Types:</b></span></h1>\n",
    "<p class=\"MsoNormal\"><span lang=\"en-PK\">In python, we have four primitive(built-in)\n",
    "data types:<o:p></o:p></span></p>\n",
    "<p class=\"MsoNormal\"></p>\n",
    "<ol style=\"text-align: left;\"><li><span lang=\"en-PK\">String</span></li><li><span lang=\"en-PK\">Integer</span></li><li><span lang=\"en-PK\">Float</span></li><li><span lang=\"en-PK\">Boolean</span></li></ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Integer\n",
    "price = 75000\n",
    "print(price)\n",
    "print(type(price))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Float\n",
    "weight = 187.5\n",
    "print(weight)\n",
    "print(type(weight))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Boolean\n",
    "sold = True #False \n",
    "print(sold)\n",
    "print(type(sold))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## String between \"\" or ''\n",
    "name = \"Iphone 11\"\n",
    "name1 = 'Iphone 11'\n",
    "print(name)\n",
    "print(type(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings are collection alphabets, words, characters. You can create string using single or double quotes\n",
    "\n",
    "str1 = \"Python\"\n",
    "\n",
    "# to add multiple lines of code\n",
    "\n",
    "sent1 = \"\"\"This is first session to Python and \n",
    "left with 5 more session's\"\"\"\n",
    "# any special characters are considered as special characters in between \"\"\"  \"\"\"\n",
    "\n",
    "print(str1)\n",
    "print(sent1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To concatenate two or more strings we can use + operator directly\n",
    "\n",
    "\"Python\" + \"Introduction\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Even a space is considered a part of a string\n",
    "\"Python\" + ' ' + \"Introduction\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To multiply the string multiple times use * operator\n",
    "\"Python\"*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <h1 style=\"text-align: left;\"><span lang=\"en-PK\"><b>Non Primitve Data Types:</b></span></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python Collections/Secondary Data Types\n",
    "\n",
    "1.List is a collection which is ordered and changeable. Allows duplicate members.\n",
    "\n",
    "2.Tuple is a collection which is ordered and unchangeable. Allows duplicate members.\n",
    "\n",
    "3.Set is a collection which is unordered and unindexed. No duplicate members.\n",
    "\n",
    "4.Dictionary is a collection which is unordered and changeable. No duplicate members."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A list is the Python equivalent of an array, but is resizeable and can contain elements of different types.\n",
    "#### A list is enclosed between [].\n",
    "#### A list is mutable unlike a tuple.\n",
    "#### It can contain another list as one of its elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creation of list\n",
    "lis1 = [10,20,30] \n",
    "type(lis1)\n",
    "l2 = list(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subsetting operations\n",
    "list2 = ['python',1,'introduction','NMIMS',True]\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list1=[1,4.5,True,\"Tej\",[4,\"Mythili\"]]\n",
    "print(my_list1)\n",
    "print(type(my_list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A list can be indexed to retrieve individual elements. Indexing starts from 0 to n-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Extract the 2nd element of the list\n",
    "my_list1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Extract the 5th element of the list\n",
    "my_list1[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract 'Mythili' from list\n",
    "my_list1[4][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list1[-1:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To get the length of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Print the len of my_list1\n",
    "\n",
    "print(len(my_list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A list is mutable, hence we can change the element/elements of a list by using its index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chnange the value of 4th element to \"Nithin\"\n",
    "\n",
    "my_list1[3]=\"Nithin\"\n",
    "print(my_list1)\n",
    "print(type(my_list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A list can be mutable so we can insert or delete elements from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Add an element value \"NMIMS\" to end of my_list1\n",
    "\n",
    "my_list1.append(\"NMIMS\")\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Insert an element value \"Python\" at 3rd position \n",
    "\n",
    "my_list1.insert(4,\"Python\")\n",
    "print(my_list1)\n",
    "print(len(my_list1))\n",
    "print(type(my_list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Delete 5th element from my_list1\n",
    "\n",
    "del my_list1\n",
    "print(my_list1)\n",
    "print(type(my_list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise\n",
    "\n",
    "list1 = []\n",
    "list1.append(2)\n",
    "list1.append(0)\n",
    "list1.append(6)\n",
    "\n",
    "#[2,0,6]\n",
    "list1.insert(3,10)\n",
    "#[2.0.6,10]\n",
    "list1.insert(3,10)\n",
    "#[2,0,6,11,10,]\n",
    "\n",
    "list1.append(20)\n",
    "list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Operations overview\n",
    "<table>\n",
    "<tbody><tr>\n",
    "<th>Method</th>\n",
    "<th>Description</th>\n",
    "</tr>\n",
    "<tr><td>append()</a></td><td>Adds an element at \n",
    "  the end of the list</td></tr>\n",
    "<tr><td>clear()</a></td><td>Removes all the \n",
    "  elements from the list</td></tr>\n",
    "<tr><td>copy()</a></td><td>Returns a copy of the \n",
    "  list</td></tr>\n",
    "<tr><td>count()</a></td><td>Returns the number of \n",
    "  elements with the specified value</td></tr>\n",
    "<tr><td>extend()</a></td><td>Add the elements of a \n",
    "  list (or any iterable), to the end of the current list</td></tr>\n",
    "<tr><td>index()</a></td><td>Returns the index of \n",
    "  the first element with the specified value</td></tr>\n",
    "<tr><td>insert()</a></td><td>Adds an element at \n",
    "  the specified position</td></tr>\n",
    "<tr><td>pop()</a></td><td>Removes the element at the \n",
    "  specified position</td></tr>\n",
    "<tr><td>remove()</a></td><td>Removes the  \n",
    "  item with the specified value</td></tr>\n",
    "<tr><td>reverse()</a></td><td>Reverses the order \n",
    "  of the list</td></tr>\n",
    "<tr><td>sort()</a></td><td>Sorts the list</td></tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b. Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A tuple can contain non homogenous elements of different datatypes.\n",
    "#### A tuple can contain another tuple as one of its elements.\n",
    "#### A tuple is enclosed between () and is immutable and ordered.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Tuple creation\n",
    "\n",
    "my_tuple = ('NMIMS',1,True)\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Create tuple and display the type\n",
    "\n",
    "my_tuple1=(1,2.4,\"Ramya\",False,(2,3,5,\"Sankar\",True))\n",
    "print(my_tuple1)\n",
    "print(type(my_tuple1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A tuple can be indexed to retrieve individual elements. Indexing starts from 0 to n-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Extract the 2nd element of the tuple\n",
    "my_tuple1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Extract the 5th element of the tuple\n",
    "my_tuple1[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the last element\n",
    "my_tuple1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the value 3 from my_tuple1\n",
    "my_tuple1[4][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To get the length of a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the length of my_tuple\n",
    "\n",
    "print(len(my_tuple1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A tuple is immutable, hence throws an error if we try to \n",
    "         1. change the element/elements of a tuple \n",
    "         2. add\n",
    "         3. delete elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Assign a value 9 at position 3 of my_tuple1\n",
    "\n",
    "my_tuple1[2]=9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Insert a new element at position\n",
    "\n",
    "my_tuple2.insert(3,\"New element\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete 3rd element from my_tuple2\n",
    "\n",
    "del my_tuple2[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [10,10]\n",
    "l1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "Sets are a collection of distinct (unique) objects. These are useful to create lists that only hold unique values in the dataset. It is an unordered collection but a mutable one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set creation\n",
    "\n",
    "set1 = {1,'NMIMS',1}\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set creation and print\n",
    "\n",
    "myset = {\"NMIMS\",\"Batch01\",\"Python\"}\n",
    "print(myset)\n",
    "print(type(myset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 181
    },
    "colab_type": "code",
    "id": "lPlBQ7BKRvf_",
    "outputId": "2137ed1d-eec7-4e94-c01e-a3493b044b65"
   },
   "outputs": [],
   "source": [
    "# Try to index an element from Set\n",
    "myset[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JM-QKoSYW91p"
   },
   "outputs": [],
   "source": [
    "# Update (Append, update)\n",
    "A = {'Jan'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "oRKVPTd0XlIz",
    "outputId": "3546dc5c-0056-468d-9491-d7794c9d186a"
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nWypTTsFXlSr"
   },
   "outputs": [],
   "source": [
    "# To add single item\n",
    "A.add(\"July\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "d_ii14jrXlet",
    "outputId": "d9db217c-ab19-4fae-e276-80c8c04b2102"
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.add('July')\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RdamdxUvXlkT"
   },
   "outputs": [],
   "source": [
    "# to add multiple items\n",
    "A.update([\"Aug\",\"Sep\",\"Oct\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "HEKF-0lZXlop",
    "outputId": "599d9005-de11-49f8-9d15-de4a58bbbb2d"
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "GYRa49bIXli0",
    "outputId": "7ef97fe6-da1b-469c-8464-6645ba90ac08"
   },
   "outputs": [],
   "source": [
    "# Delete an item from set\n",
    "A.pop() #\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GYgpC1noXlc3"
   },
   "outputs": [],
   "source": [
    "# TO delete a particular element from set. \n",
    "# Delete \"Jan\" from set A\n",
    "A.remove(\"Aug\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "aUnbb2zfXlaM",
    "outputId": "8df4914a-c585-4cec-e1f1-074150ca1b55"
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some basic operations on Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zJmnjLJIWF5t"
   },
   "outputs": [],
   "source": [
    "\n",
    "A = {\"Jan\",\"Feb\",\"Mar\"}\n",
    "B = {\"Mar\",\"Jun\"}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1vXdctyuWp41",
    "outputId": "c133ac77-a5bb-49a9-c857-909133d6c108"
   },
   "outputs": [],
   "source": [
    "# Get the union of A and B\n",
    "\n",
    "A.union(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "48atbNs4WvRj",
    "outputId": "4eea1fda-20b3-4769-f4c8-50bb84bc818b"
   },
   "outputs": [],
   "source": [
    "# Get the intersection of A and B\n",
    "\n",
    "A.intersection(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "24kN6XqUXlX7"
   },
   "outputs": [],
   "source": [
    "\n",
    "a = {\"Bhanu\",\"Tejaswi\"}\n",
    "b = {\"Shaja\",\"Bhanu\",\"Swetha\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "RUlTBtuqXlVv",
    "outputId": "00d0319b-1aaa-43d2-9427-fd19b1a36c23"
   },
   "outputs": [],
   "source": [
    "# Get the difference of a and b\n",
    "\n",
    "a.difference(b) # a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "sXI1HS0qZrS2",
    "outputId": "52b67351-4972-4d6d-fc66-ba7e6ef8f497"
   },
   "outputs": [],
   "source": [
    "# Get the difference of b and a\n",
    "\n",
    "b.difference(a) # b - a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set methods summary\n",
    "\n",
    "<table>\n",
    "<tbody><tr>\n",
    "<th>Method</th>\n",
    "<th>Description</th>\n",
    "</tr>\n",
    "<tr><td>add()</a></td><td>Adds an element to the \n",
    "  set</td></tr>\n",
    "<tr><td>clear()</a></td><td>Removes all the \n",
    "  elements from the set</td></tr>\n",
    "<tr><td>copy()</a></td><td>Returns a copy of the set</td></tr>\n",
    "  <tr>\n",
    "    <td>difference()</a></td><td>Returns a set \n",
    "    containing the difference between two or more sets</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>difference_update()</a></td><td>Removes the \n",
    "    items in this set that are also included in another, specified set</td>\n",
    "  </tr>\n",
    "<tr><td>discard()</a></td><td>Remove the specified \n",
    "  item</td></tr>\n",
    "  <tr>\n",
    "    <td>intersection()</a></td><td>Returns a set, \n",
    "    that is the intersection of two other sets</td>\n",
    "  </tr>\n",
    "<tr><td>intersection_update()</a></td><td>\n",
    "  Removes the items in this set that are not present in other, specified set(s)</td></tr>\n",
    "  <tr>\n",
    "    <td>isdisjoint()</a></td><td>Returns whether \n",
    "    two sets have a intersection or not</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>issubset()</a></td><td>Returns whether \n",
    "    another set contains this set or not</td>\n",
    "  </tr>\n",
    "<tr><td>issuperset()</a></td><td>Returns whether \n",
    "  this set contains another set or not</td></tr>\n",
    "<tr><td>pop()</a></td><td>Removes an element from the \n",
    "  set</td></tr>\n",
    "<tr><td>remove()</a></td><td>Removes the specified element</td></tr>\n",
    "  <tr>\n",
    "    <td>symmetric_difference()</a></td><td>Returns \n",
    "    a set with the symmetric differences of two sets</td>\n",
    "  </tr>\n",
    "<tr><td>symmetric_difference_update()</a></td><td>\n",
    "  inserts the symmetric differences from this set and another</td></tr>\n",
    "  <tr>\n",
    "    <td>union()</a></td><td>Return a set containing \n",
    "    the union of sets</td>\n",
    "  </tr>\n",
    "<tr><td>update()</a></td><td>Update the set with the \n",
    "  union of this set and others</td></tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A dictionary is a collection which is unordered, mutable and indexed.\n",
    "#### It is represented by a key, value pair. It can contain key values of different datatypes.\n",
    "#### It is enclosed between {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creation of dictionary\n",
    "\n",
    "dict1 = {\n",
    "    'name': \"banu\",\n",
    "    'age':'25',\n",
    "    'qualification':'BSC'\n",
    "}\n",
    "\n",
    "print(dict1)\n",
    "type(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A dictionary is indexed by its keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "yPwTw3IEYBAE",
    "outputId": "1bf1c0bb-93a1-4d8e-ec74-6151533c9805"
   },
   "outputs": [],
   "source": [
    "# get the value of name key\n",
    "\n",
    "dict1['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "2C8anzvIYNFx",
    "outputId": "ddc68ca8-4bb0-4e24-82ff-f5f75e7f7fd7"
   },
   "outputs": [],
   "source": [
    "# get the value of age key\n",
    "\n",
    "dict1['age']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To get the length of a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Length of a dictionary\n",
    "\n",
    "print(len(dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To modify the values of a dictionary, use their keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modify the age to 30\n",
    "\n",
    "dict1[\"age\"]=30\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1['age2'] = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To add an element to a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add a new key to dict1 with value \"Hyd\"\n",
    "\n",
    "dict1[\"location\"]=\"Hyd\"\n",
    "print(dict1)\n",
    "print(len(dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To delete an element from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete \"location\" key from dict1\n",
    "\n",
    "del dict1[\"location\"]\n",
    "print(dict1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To delete an element from a dictionary using pop**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Way 2 to delete an element. Delete \"name\" key from dict1\n",
    "\n",
    "dict1.pop('name')\n",
    "print(dict1)\n",
    "print(type(dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested distionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict2 = {\n",
    "    'stu1' : {'name':'banu','age':'25','qualification':{'k1':'v2','k2':'v2'}},\n",
    "    'stu2' : {'name1':'shanmukh','age1':'24','qualification1':'cse'} ,\n",
    "    'stu3' : {'name2':'Swetha','age2':'24','qualification2':'MBBS'}  \n",
    "}\n",
    "dict2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ojIJVXfDeE6p",
    "outputId": "7c2a1048-58b4-427f-ce47-350117d2eae5"
   },
   "outputs": [],
   "source": [
    "# access 'banu' from dict2\n",
    "dict2['stu1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict2['stu1']['qualification']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict2['stu1']['qualification']['k1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary methods overview\n",
    "\n",
    "\n",
    "<table>\n",
    "<tbody><tr>\n",
    "<th>Method</th>\n",
    "<th>Description</th>\n",
    "</tr>\n",
    "<tr><td>clear()</a></td><td>Removes all the elements from the dictionary</td></tr>\n",
    "<tr><td>copy()</a></td><td>Returns a copy of the dictionary</td></tr>\n",
    "<tr><td>fromkeys()</a></td><td>Returns a dictionary with the specified keys and value</td></tr>\n",
    "<tr><td>get()</a></td><td>Returns the value of the specified key</td></tr>\n",
    "<tr><td>items()</a></td><td>Returns a list containing a tuple for each key value pair</td></tr>\n",
    "<tr><td>keys()</a></td><td>Returns a list containing the dictionary's keys</td></tr>\n",
    "<tr><td>pop()</a></td><td>Removes the element with the specified key</td></tr>\n",
    "<tr><td>popitem()</a></td><td>Removes the last \n",
    "  inserted key-value pair</td></tr>\n",
    "<tr><td>setdefault()</a></td><td>Returns the value of the specified key. If the key does not exist: insert the key, with the specified value</td></tr>\n",
    "<tr><td>update()</a></td><td>Updates the dictionary with the specified key-value pairs</td></tr>\n",
    "<tr><td>values()</a></td><td>Returns a list of all the values in the dictionary</td></tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pIkjhRg9Rkn2"
   },
   "source": [
    "tuples = () or tuple() \n",
    "\n",
    "lists = [] or list()\n",
    " \n",
    "dictionaries  = {}(key and value)\n",
    "\n",
    "sets = {}  \n",
    "\n",
    "How we will read tuples or list --> By using index ### Dictionary methods overview\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Copying any data structures\n",
    "\n",
    "list1 = [10,20,30,40]\n",
    "\n",
    "list2 = list1\n",
    "\n",
    "list2[0] = 100\n",
    "\n",
    "print(list1)\n",
    "\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Copying any data structures\n",
    "\n",
    "list1 = [10,20,30,40]\n",
    "\n",
    "list2 = list1.copy()\n",
    "\n",
    "list2[0] = 100\n",
    "\n",
    "print(list1)\n",
    "\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Data Type Conversion/Type Casting </h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Python defines type conversion functions to directly convert one data type to another </p>\n",
    "<p>There are two types of Type Conversion in Python:</p>\n",
    "<ol><li>Implicit Type Conversion</li><li>Explicit Type Conversion</li></ol>\n",
    "\n",
    "<h2 style=\"text-align:center\">Implicit Type Conversion</h2>\n",
    "\n",
    "<p>In Implicit type conversion of data types in Python, the Python interpreter automatically converts one data type to another without any user involvement. </p>\n",
    "\n",
    "<h2 style=\"text-align:center\">Explicit Type Conversion</h2>\n",
    "<p>In Explicit Type Conversion in Python, the data type is manually changed by the user as per their requirement. Various form of explicit type conversion are explained below:<br>&nbsp;</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-align:center\">Implicit Type Conversion</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_int = 123\n",
    "print(\"Type of num_int\",type(num_int))\n",
    "num_float = 456.1\n",
    "print(\"Type of num_float\",type(num_float))\n",
    "\n",
    "num_int + num_float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_int = 10\n",
    "print(\"Type of num_int\",type(num_int))\n",
    "num_str = \"20\"\n",
    "print(\"Type of num_str\",type(num_str))\n",
    "\n",
    "num_int + num_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-align:center\">Explicit Type Conversion</h2>\n",
    "<table class=\"grey\">\n",
    "<tbody><tr>\n",
    "<td class=\"greyout\"><b>Function</b></td>\n",
    "<td class=\"greyout\"><b>Converting what to what</b></td>\n",
    "<td class=\"greyout\"><b>Example</b></td>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">int()</tt></td>\n",
    "<td><br>string, floating point → integer </td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>int(<span class=\"pysrc-string\">'2014'</span>) \n",
    "<span class=\"pysrc-output\">2014</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>int(3.141592)\n",
    "<span class=\"pysrc-output\">3</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">float()</tt></td>\n",
    "<td><br>string, integer → floating point number</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>float(<span class=\"pysrc-string\">'1.99'</span>) \n",
    "<span class=\"pysrc-output\">1.99</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>float(5)\n",
    "<span class=\"pysrc-output\">5.0</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">str()</tt></td>\n",
    "<td><br>integer, float, list, tuple, dictionary → string</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>str(3.141592) \n",
    "<span class=\"pysrc-output\">'3.141592'</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>str([1,2,3,4])\n",
    "<span class=\"pysrc-output\">'[1, 2, 3, 4]'</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">list()</tt></td>\n",
    "<td><br>string, tuple, set, dictionary → list</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>list(<span class=\"pysrc-string\">'Mary'</span>)      <span class=\"pysrc-comment\"># list of characters in 'Mary'</span> \n",
    "<span class=\"pysrc-output\">['M', 'a', 'r', 'y']</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>list((1,2,3,4))   <span class=\"pysrc-comment\"># (1,2,3,4) is a tuple</span>\n",
    "<span class=\"pysrc-output\">[1, 2, 3, 4]</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>list({1, 2, 3})   <span class=\"pysrc-comment\"># {1, 2, 3} is a set</span>\n",
    "<span class=\"pysrc-output\">[1, 2, 3]</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">tuple()</tt></td>\n",
    "<td><br>string, list, set → tuple</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>tuple(<span class=\"pysrc-string\">'Mary'</span>)\n",
    "<span class=\"pysrc-output\">('M', 'a', 'r', 'y')</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>tuple([1,2,3,4])   <span class=\"pysrc-comment\"># [ ] for list, ( ) for tuple</span>\n",
    "<span class=\"pysrc-output\">(1, 2, 3, 4)</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">set()</tt></td>\n",
    "<td><br>string, list, tuple → set</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>set(<span class=\"pysrc-string\">'alabama'</span>)            <span class=\"pysrc-comment\"># unique character set from a string</span>\n",
    "<span class=\"pysrc-output\">{'b', 'm', 'l', 'a'}</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>set([1, 2, 3, 3, 3, 2])   <span class=\"pysrc-comment\"># handy for removing duplicates from list</span>\n",
    "<span class=\"pysrc-output\">{1, 2, 3}</span> \n",
    "</pre></td></tr>\n",
    "    \n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">dict()</tt></td>\n",
    "<td><br>tuple of order(key,value) → dict (This function is used to convert a tuple of order (key,value) into a dictionary.)</td>\n",
    "<td><br>tup = (('a', 1) ,('f', 2), ('g', 3)) , dict(tup) , {'a': 1, 'f': 2, 'g': 3}\n",
    "</td></tr>\n",
    "\n",
    "    \n",
    "    \n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_int = 10\n",
    "print(\"Type of num_int\",type(num_int))\n",
    "num_str = \"20\"\n",
    "print(\"Type of num_str\",type(num_str))\n",
    "\n",
    "num_str = int(num_str)\n",
    "\n",
    "num_int + num_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str1 = \"python\"\n",
    "tuple(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [('a',1),('b',10),('c',20)]\n",
    "dict(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Additional information\n",
    "# To convert data types using astype\n",
    "\n",
    "[1,2,3] + list({2,3,4})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operatores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python divides the operators in the following groups:\n",
    "\n",
    "1. Arithmetic operators\n",
    "2. Assignment operators\n",
    "3. Comparison operators\n",
    "4. Logical operators\n",
    "5. Membership operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Arithmetic Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Name</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+</td>\n",
    "<td>Addition</td>\n",
    "<td>x + y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>-</td>\n",
    "<td>Subtraction</td>\n",
    "<td>x - y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>*</td>\n",
    "<td>Multiplication</td>\n",
    "<td>x * y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>/</td>\n",
    "<td>Division</td>\n",
    "<td>x / y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>%</td>\n",
    "<td>Modulus</td>\n",
    "<td>x % y</td>\n",
    "</tr>\n",
    "  <tr>\n",
    "<td>**</td>\n",
    "<td>Exponentiation</td>\n",
    "<td>x ** y</td>\n",
    "  </tr>\n",
    "<tr>\n",
    "<td>//</td>\n",
    "<td>Floor division</td>\n",
    "<td>x // y</td>\n",
    "</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 13\n",
    "b = 5\n",
    "\n",
    "a//b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Assignment Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:20%\">Example</th>\n",
    "<th style=\"width:20%\">Same As</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>=</td>\n",
    "<td>x = 5</td>\n",
    "<td>x = 5</td>\n",
    "</tr>\n",
    "  <tr>\n",
    "<td>+=</td>\n",
    "<td>x += 3</td>\n",
    "<td>x = x + 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>-=</td>\n",
    "<td>x -= 3</td>\n",
    "<td>x = x - 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>*=</td>\n",
    "<td>x *= 3</td>\n",
    "<td>x = x * 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>/=</td>\n",
    "<td>x /= 3</td>\n",
    "<td>x = x / 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>%=</td>\n",
    "<td>x %= 3</td>\n",
    "<td>x = x % 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>//=</td>\n",
    "<td>x //= 3</td>\n",
    "<td>x = x // 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>**=</td>\n",
    "<td>x **= 3</td>\n",
    "<td>x = x ** 3</td>\n",
    "  </tr>\n",
    "\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Comparision Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Name</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==</td>\n",
    "<td>Equal</td>\n",
    "<td>x == y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>!=</td>\n",
    "<td>Not equal</td>\n",
    "<td>x != y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;</td>\n",
    "<td>Greater than</td>\n",
    "<td>x &gt; y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;</td>\n",
    "<td>Less than</td>\n",
    "<td>x &lt; y</td>\n",
    "</tr>\n",
    "  <tr>\n",
    "<td>&gt;=</td>\n",
    "<td>Greater than or equal to</td>\n",
    "<td>x &gt;= y</td>\n",
    "  </tr>\n",
    "<tr>\n",
    "<td>&lt;=</td>\n",
    "<td>Less than or equal to</td>\n",
    "<td>x &lt;= y</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"\">\n",
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Description</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>and&nbsp;</td>\n",
    "<td>Returns True if both statements are true</td>\n",
    "<td>x &lt; 5 and&nbsp; x &lt; 10</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>or</td>\n",
    "<td>Returns True if one of the statements is true</td>\n",
    "<td>x &lt; 5 or x &lt; 4</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>not</td>\n",
    "<td>Reverse the result, returns False if the result is true</td>\n",
    "<td>not(x &lt; 5 and x &lt; 10)</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Membership Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Description</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "\n",
    "</tr>\n",
    "<tr>\n",
    "<td>in&nbsp;</td>\n",
    "<td>Returns True if a sequence with the specified value is present in the object</td>\n",
    "<td>x in y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>not in</td>\n",
    "<td>Returns True if a sequence with the specified value is not present in the \n",
    "object</td>\n",
    "<td>x not in y</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "2OSqzORfVxa3",
    "outputId": "03e40422-9c97-4688-c78d-655671728f9e"
   },
   "outputs": [],
   "source": [
    "\"Jan\" in set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "ZXJ08r8dSezk",
    "outputId": "07727463-7a53-4e3a-deb2-feff0de95483"
   },
   "outputs": [],
   "source": [
    "for i in set1:\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if - else "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = float(input(\"Enter a number: \"))\n",
    "if num >= 0:\n",
    "    if num == 0:\n",
    "        print(\"Zero\")\n",
    "    else:\n",
    "        print(\"Positive number\")\n",
    "else:\n",
    "    print(\"Negative number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = float(input(\"Enter a number: \"))\n",
    "if num == 0:\n",
    "    print(\"Zero\")\n",
    "elif num >0:\n",
    "    print(\"Positive number\")\n",
    "#elif num > 10 & num <20:\n",
    "#    print(\"number lies between 10 and 20\")\n",
    "else:\n",
    "    print(\"Negative number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Short hand if statement\n",
    "\n",
    "a = input(int())\n",
    "b = input(int())\n",
    "if a > b: print(\"If condition works and a is greater than b !!\")\n",
    "else :\n",
    "        print('if condition fails, hence we enter else loop and a is not greater than b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Short hand of if-else statement\n",
    "marks = float(input(\"Enter marks of student:\"))\n",
    "\n",
    "print(\"Student passed\") if marks > 36 else print(\"Student failed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = float(input(\"Enter a number: \"))\n",
    "#if num == 0:\n",
    "#    print(\"Zero\")\n",
    "#elif num >0:\n",
    "#    print(\"Positive number\")\n",
    "#else:\n",
    "#    print(\"Negative number\")\n",
    "    \n",
    "print(\"zero\") if num == 0 else print(\"Positive number\") if num >0 else print(\"Negative Number\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}