2. Data Structures in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fbfdc3f6",
   "metadata": {},
   "source": [
    "# Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a68282eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuples are similar to lists in almost of their functionalities, \n",
    "# there is one significant difference in both the data structures lists are mutable and tuples are not. \n",
    "# Heterogenous\n",
    "# Tuples are an ordered sequence of mixed data types.\n",
    "# Tuples are written as comma-separated elements within parenthesis\n",
    "\n",
    "tuple1 = (1,45,23,2334,5,662,434,54,45,6,77,66, 'Sam', 12.34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9ee778ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('disco', 12, 4.5)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (\"disco\", 12, 4.5)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2b241617",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d8586ee6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "213357f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "662"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing\n",
    "\n",
    "tuple1[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "94b78a05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tuple1[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ad2cc00a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tuple1[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "da98d77e",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (1,45,23,2334,5,662)\n",
    "tuple2=(434,54,45,6,77,66)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c31885b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 45, 23, 2334, 5, 662, 434, 54, 45, 6, 77, 66)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1+tuple2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f761b78a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 45, 1, 45, 1, 45, 1, 45)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[:2]*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0dcb63ad",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_5088/4004573393.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtuple1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tuple1[5] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "539a9ebd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "# A tuple can be defined without using parenthesis \n",
    "\n",
    "sample_tuple = 1,2,3,4\n",
    "print(sample_tuple)\n",
    "\n",
    "\n",
    "sample_tuple = 1,  \n",
    "print(sample_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "930cedfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_tuple1 = 1   # This is not a tuple\n",
    "sample_tuple2 = (1) # This is not a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6251f5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuple is immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "b957c32f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (1,45,23,2334,5,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "aadf6894",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "9700c01e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate tuple (not \"str\") to tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_5088/2160534525.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtuple1\u001b[0m\u001b[1;33m+\u001b[0m \u001b[1;34m\"5\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate tuple (not \"str\") to tuple"
     ]
    }
   ],
   "source": [
    "tuple1+ \"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0332133b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# concatenate similar types only!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "e43b5a56",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"str\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_5088/705400979.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ml\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ml\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m\"5\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate list (not \"str\") to list"
     ]
    }
   ],
   "source": [
    "l = []\n",
    "l+\"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "7e06f320",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Seattle', 84, 'Python')"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing \n",
    "\n",
    "t = (\"Seattle\", 84, \"Python\", 5, 2, 1)\n",
    "\n",
    "t[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "884bf8a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Slicing last 2 elements from t\n",
    "\n",
    "t = (\"Seattle\", 84, \"Python\", 5, 2, 1)\n",
    "\n",
    "t[-2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "64b2fc01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('This', 'is', 'Session', 2, 'on', 'Tuples')"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cancatenating tuples\n",
    "\n",
    "tup1 = (\"This\", \"is\", \"Session\", 2)\n",
    "tup2 = (\"on\", \"Tuples\")\n",
    "\n",
    "# Adding contents of tup2 to tup1 and storing in tup3\n",
    "\n",
    "tup3 = tup1 + tup2\n",
    "\n",
    "tup3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "445925a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (2, 4, 3, 5, 7)\n",
    "sum(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c59469d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (2, 4, 3, 5, 7)\n",
    "max(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd3787df",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (2, 4, 3, 5, 7)\n",
    "min(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "80407470",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_5088/3812800556.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"USA\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"Disco\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m7.5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Hard Rock\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Immutability of tuples\n",
    "\n",
    "t = (\"USA\", 4, 3, \"Disco\", 7.5)\n",
    "\n",
    "t[3] = \"Hard Rock\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "b1263b0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('USA', 4, 3, 'Hard Rock', 7.5)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_t = t[0:3] + (\"Hard Rock\",) + t[4:]\n",
    "new_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "8333e919",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, 2, 3, 4, 5, 6, 8]"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting a tuple\n",
    "\n",
    "t = (2,3,6,4,8,5, -1)\n",
    "sorted(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "5a7e3322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-1, 2, 3, 4, 5, 6, 8)\n",
      "(2, 3, 6, 4, 8, 5, -1)\n"
     ]
    }
   ],
   "source": [
    "t = (2,3,6,4,8,5, -1)\n",
    "x = sorted(t)\n",
    "\n",
    "print(tuple(x))\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "999b2aa2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Packing and Unpacking In Tuples\n",
    "\n",
    "t = (1,2,3,4)     # Packing \n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "f119b729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "(a,b,c,d) = t     # Unpacking \n",
    "print (c)\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "89c8b063",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_5088/4269185244.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mt\u001b[0m     \u001b[1;31m# Unpacking\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 3)"
     ]
    }
   ],
   "source": [
    "(a,b,c) = t     # Unpacking \n",
    "print (c)\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d60d6412",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dir() function only gives the list of methods available\n",
    "# help() function gives a brief description of each of the methods available with tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa3fd5ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ba90948",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dir() - to view the attributes or methods of an object\n",
    "\n",
    "dir(tuple1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "25971dea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Monty Python', 'British', 1969, 'Python')"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the element ‘Python’ to a tuple input_tuple = ('Monty Python', 'British', 1969). \n",
    "\n",
    "inp = ('Monty Python', 'British', 1969)\n",
    "out = inp + (\"Python\",)\n",
    "out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "f095c4ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of animals in the zoo is 3\n",
      "Number of cages in the new zoo is 3\n",
      "All animals in new zoo are ('monkey', 'camel', ('python', 'elephant', 'penguin'))\n",
      "Animals brought from old zoo are ('python', 'elephant', 'penguin')\n",
      "Last animal brought from old zoo is penguin\n",
      "Number of animals in the new zoo is 5\n"
     ]
    }
   ],
   "source": [
    "zoo = ('python', 'elephant', 'penguin')\n",
    "print('Number of animals in the zoo is', len(zoo))\n",
    "\n",
    "new_zoo = 'monkey', 'camel', zoo    # parentheses not required but are a good idea\n",
    "print('Number of cages in the new zoo is', len(new_zoo))\n",
    "print('All animals in new zoo are', new_zoo)\n",
    "print('Animals brought from old zoo are', new_zoo[2])\n",
    "print('Last animal brought from old zoo is', new_zoo[2][2])\n",
    "print('Number of animals in the new zoo is',\n",
    "      len(new_zoo)-1+len(new_zoo[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64b6d900",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "ddb0480a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are an ordered sequnce of mixed data types.\n",
    "# Lists are written as comma-separated elements within square brackets\n",
    "# Heterogenous\n",
    "\n",
    "l1 = [1,45,23,2334,5,662,434,54,45,6,77,66, 'Sam', 12.34, False]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "0f3f2f65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['USA', 23, 6, 'New York']"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [\"USA\", 23, 6, \"New York\"]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "d09dd917",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Biology', [1989, 2004], ('Oreily', 'Pearson')]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nested List\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "4485acd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Chemistry'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "\n",
    "L[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "5d216b78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Biology'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "23f48fff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pearson'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-1][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "e76c0c52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2004"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-2][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "5a7257bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "b1afc7b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "d410301e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Biology', [1989, 2004]]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing\n",
    "\n",
    "L[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "46fb01a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sam'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "b63bdf78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 45, 23]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "e1e84084",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "45\n",
      "23\n",
      "2334\n",
      "5\n",
      "662\n",
      "434\n",
      "54\n",
      "45\n",
      "6\n",
      "77\n",
      "66\n",
      "Sam\n",
      "12.34\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "for ele in l1:\n",
    "    print(ele)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "eadf66cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 45, 23, 2334, 5, 662, 434, 54, 45, 6, 77, 66, 'Sam', 12.34, False]\n"
     ]
    }
   ],
   "source": [
    "print(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "c9b1ed2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "l1.append([100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "139923f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 45, 23, 2334, 5, 662, 434, 54, 45, 6, 77, 66, 'Sam', 12.34, False, [100]]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "d3d20472",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 45,\n",
       " 23,\n",
       " 2334,\n",
       " 5,\n",
       " 662,\n",
       " 434,\n",
       " 54,\n",
       " 45,\n",
       " 6,\n",
       " 77,\n",
       " 66,\n",
       " 'Sam',\n",
       " 12.34,\n",
       " False,\n",
       " [100],\n",
       " 200]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1.append(200)\n",
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "3bd61f1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "l1.extend([2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "e5b38220",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 45,\n",
       " 23,\n",
       " 2334,\n",
       " 5,\n",
       " 662,\n",
       " 434,\n",
       " 54,\n",
       " 45,\n",
       " 6,\n",
       " 77,\n",
       " 66,\n",
       " 'Sam',\n",
       " 12.34,\n",
       " False,\n",
       " [100],\n",
       " 200,\n",
       " 2,\n",
       " 3,\n",
       " 4]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db0ecfb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# append and extend\n",
    "\n",
    "#extend - add individual elements as list elements\n",
    "#append - appends the elements in [] as one element\n",
    "#del -delete element at the index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "e6e72ca0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Biology', [1989, 2004], ('Oreily', 'Pearson'), 5, 8]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# extend()\n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "L.extend([5, 8])\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "2b6d6f27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Biology', [1989, 2004], ('Oreily', 'Pearson'), [5, 8]]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# append()\n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "L.append([5, 8])\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "873fd03d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Biology', [1989, 2004], ('Oreily', 'Pearson')]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# del Command\n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "del L[0]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "1efb7f2f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del L[0:2]\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "26eb6185",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Biology', [1989, 2004]]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pop() \n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "\n",
    "L.pop()\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "b0f41134",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Biology', [1989, 2004], ('Oreily', 'Pearson'), 'Chemistry']"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# remove()\n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\"), \"Chemistry\"]\n",
    "\n",
    "L.remove(\"Chemistry\")\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "3a9a707a",
   "metadata": {},
   "outputs": [],
   "source": [
    "l2 =[1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "f44340ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "155a7df6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "d491a0fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "a38fa8d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "l2.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "9e153b3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 1]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "090bd33c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# reverse() - mutable - changed in original list - in-place change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3284cf22",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "149d3fdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33b9fd99",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Membership in Lists\n",
    "\n",
    "L1 = [1,2,3,4]\n",
    "print(1 in L1)  # True\n",
    "print (8 not in L1)  # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb24e2ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "100 in l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4bf3986",
   "metadata": {},
   "outputs": [],
   "source": [
    "2 in l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "c772c7b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Biology', [1989, 2004], ('Oreily', 'Pearson'), 5, 8]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List Concatanetion\n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "new_L = L + [5, 8]\n",
    "new_L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "2054e70a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chemistry', 'Physics', [1989, 2004], ('Oreily', 'Pearson')]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Replace \"Biology\" with \"Physics\"\n",
    "\n",
    "L = [\"Chemistry\", \"Biology\", [1989, 2004], (\"Oreily\", \"Pearson\")]\n",
    "\n",
    "L[1] = \"Physics\"\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "b3f5f4cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "l1= [1,2,3,4]\n",
    "t1=(1,2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "e32f374b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 24, 32, 65]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting Lists\n",
    "\n",
    "l = [32, 24, 65, 9]\n",
    "l.sort()\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "d3cb6190",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[65, 32, 24, 9]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.sort(reverse= True)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "e81d46ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mango', 'Orange', 'Strawberry']\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Difference between sort and sorted\n",
    "\n",
    "A = [\"Orange\", \"Strawberry\", \"Mango\"]\n",
    "B = A.sort()\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7607494c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Orange', 'Strawberry', 'Mango']\n",
      "['Mango', 'Orange', 'Strawberry']\n"
     ]
    }
   ],
   "source": [
    "A = [\"Orange\", \"Strawberry\", \"Mango\"]\n",
    "C = sorted(A)\n",
    "\n",
    "print(A)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4c7d3228",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sort() - sorts in-place - orginal list is sorted\n",
    "# sorted() - does not mofify the orginal list, function retuens sorted list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "947592b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shallow copying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "1974fb1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A and B refer to the same list object in the memory, and the changes made to list A will be reflected in list B as well. \n",
    "\n",
    "A = [\"Orange\", \"Strawberry\", \"Mango\"]\n",
    "B = A\n",
    "\n",
    "A[0] = \"Apple\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "0efe70b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1715303574144"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "a6665ca3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1715303574144"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f29202cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Apple', 'Strawberry', 'Mango']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "699f3f06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Apple', 'Strawberry', 'Mango']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "8eaaee5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A[:] - creating a new object,\n",
    "# New object is assigned to B\n",
    "# Any changes in list A wouldn’t affect list B anymore.\n",
    "\n",
    "A = [\"Orange\", \"Strawberry\", \"Mango\"]\n",
    "B = A[:]    \n",
    "# Note 'A[:]' is used to call all the values stored in A\n",
    "# Now B has all the values of A but isn't a Shallow copy of A\n",
    "# Shallow copy is basically assigning multiple labels to a single reference point or memory location\n",
    "\n",
    "A[0] = \"Apple\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "7c5e6ac6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1715304343232"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "396135b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1715304402176"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b276ca72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Apple', 'Strawberry', 'Mango']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "07147a58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orange', 'Strawberry', 'Mango']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5cd47c50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# extend(): Extend a list by adding elements at the end of the list.\n",
    "# append(): Append an object to the end of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "76a3e06c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the append() method takes an object passed as a single element and adds it to the end of the list\n",
    "# the extend() takes an object passed as an iterable and adds every element in the iterable at the end of the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "79191553",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pop(index): Remove and return the item at index (default last)\n",
    "# remove(value): Remove the first occurrence of a value in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "fc692d6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sort(): sorts the elements of a list in place\n",
    "# sorted(): assign the sorted elements to a new list. And the original list is left as is. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "522c524f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove SPSS from input_list=['SAS', 'R', 'PYTHON', 'SPSS'] and add 'SPARK' in its place.\n",
    "\n",
    "# Sample Input: ['SAS', 'R', 'PYTHON', 'SPSS']\n",
    "# Sample Output: ['SAS', 'R', 'PYTHON', 'SPARK']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "2105f00d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['SAS', 'R', 'PYTHON', 'SPARK']\n"
     ]
    }
   ],
   "source": [
    "input_list = ['SAS', 'R', 'PYTHON', 'SPSS']\n",
    "input_list.pop(-1)\n",
    "input_list.append('SPARK')\n",
    "print(input_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2786e361",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['SAS', 'R', 'PYTHON', 'SPARK']\n"
     ]
    }
   ],
   "source": [
    "input_list = ['SAS', 'R', 'PYTHON', 'SPSS']\n",
    "input_list[-1] = 'SPARK'\n",
    "print(input_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e63b16bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pythons syntax is easy to learn & Pythons syntax is very clear\n"
     ]
    }
   ],
   "source": [
    "# Convert a list ['Pythons syntax is easy to learn', 'Pythons syntax is very clear'] to a string using ‘&’. \n",
    "inp  = ['Pythons syntax is easy to learn', 'Pythons syntax is very clear']\n",
    "str = inp[0] + ' & ' + inp[1]\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "d1791b66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ravi\n",
      "Kumar\n",
      "003\n"
     ]
    }
   ],
   "source": [
    "# Split the string input_str = 'Kumar_Ravi_003' to the person's second name, first name and unique customer code.\n",
    "# In this example, second_name= 'Kumar', first_name= 'Ravi', customer_code = '003'.\n",
    "\n",
    "input_str = 'Kumar_Ravi_003'\n",
    "first_name = input_str.split(\"_\")[1]\n",
    "second_name = input_str.split(\"_\")[0]\n",
    "customer_code = input_str.split(\"_\")[2]\n",
    "\n",
    "print(first_name)\n",
    "print(second_name)\n",
    "print(customer_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "b05ec53a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kumar Ravi 003'"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_str = 'Kumar_Ravi_003'\n",
    "l = input_str.split(\"_\")\n",
    "' '.join(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "9cb6d2c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lists and tuples are ordered sequences. \n",
    "# Sets are unordered sequences.This makes sets unfit for indexing or slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "36785a1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 4 items to purchase.\n",
      "These items are: apple mango carrot banana \n",
      "I also have to buy rice.\n",
      "My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']\n",
      "I will sort my list now\n",
      "Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']\n",
      "The first item I will buy is apple\n",
      "I bought the apple\n",
      "My shopping list is now ['banana', 'carrot', 'mango', 'rice']\n"
     ]
    }
   ],
   "source": [
    "# This is my shopping list\n",
    "shoplist = ['apple', 'mango', 'carrot', 'banana']\n",
    "\n",
    "print('I have', len(shoplist), 'items to purchase.')\n",
    "\n",
    "print('These items are:', end=' ')\n",
    "for item in shoplist:\n",
    "    print(item, end=' ')\n",
    "\n",
    "print('\\nI also have to buy rice.')\n",
    "shoplist.append('rice')\n",
    "print('My shopping list is now', shoplist)\n",
    "\n",
    "print('I will sort my list now')\n",
    "shoplist.sort()\n",
    "print('Sorted shopping list is', shoplist)\n",
    "\n",
    "print('The first item I will buy is', shoplist[0])\n",
    "olditem = shoplist[0]\n",
    "del shoplist[0]\n",
    "print('I bought the', olditem)\n",
    "print('My shopping list is now', shoplist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb98dc59",
   "metadata": {},
   "source": [
    "# Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "935a147e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sets are a type of collection like lists and tuples, storing mixed data.\n",
    "# Sets are enclosed within curly brackets and elements are written as comma-separated.\n",
    "# Sets are unordered\n",
    "# Sets do not allow duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "d85ec63e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set and dictionaty\n",
    "\n",
    "var = {}\n",
    "\n",
    "# type is dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "8d49315f",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 ={}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "1cff6cb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "8381718b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "d3d5a0e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "5b83cac4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "38f66a54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = int(5)\n",
    "type(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "db5135e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = {1,2,3,1,2,3,3,2,1,4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "cb65a76d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# distinct elements\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "1bce352b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "468f2018",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1.add(100)\n",
    "s1.add(\"Australia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "eea6cc15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 100, 2, 3, 4, 'Australia'}"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "dfa87763",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1.remove(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "94517c8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 'Australia'}"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "af039337",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 8}\n",
      "{0, 1, 2, 3, 4, 5, 6, 8}\n",
      "{2, 4}\n",
      "{2, 4}\n",
      "{0, 8, 6}\n",
      "{0, 8, 6}\n",
      "{0, 1, 3, 5, 6, 8}\n"
     ]
    }
   ],
   "source": [
    "# Set Operations\n",
    "\n",
    "A = {0, 2, 4, 6, 8}\n",
    "B = {1, 2, 3, 4, 5}\n",
    "\n",
    "# Union represents the total unique elements in both sets.\n",
    "print(A | B) # Union\n",
    "print (A.union(B))\n",
    "\n",
    "# Intersection represents the elements common to both sets.\n",
    "print(A & B) # Intersection\n",
    "print(A.intersection(B))\n",
    "\n",
    "# Difference(A-B) represents the elements present in A and not in B.\n",
    "print(A - B) # Difference\n",
    "print(A.difference(B))  # only A elements\n",
    "\n",
    "# Symmetric difference represents the union of the elements A and B minus the intersection of A and B.\n",
    "print(A ^ B) # Symmetric Difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "fb20c4ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = {1,2,3,4}\n",
    "s2 = {1,4,5,6,4,6,4,23}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ad3d9f9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 23}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.union(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "ae3bb9da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.intersection(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "0dc5af68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 - s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a8ab5c41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.difference(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "354e4eb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1.remove(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "15a76196",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d3331807",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# Let’s say you have two lists A and B. \n",
    "# Identify the elements which are common in the two lists A and B and return them in a sorted manner. \n",
    "\n",
    "A = [5, 1, 3, 4, 4, 5, 6, 7]\n",
    "B = [3, 3, 5, 5, 1 ,7 ,2]\n",
    "\n",
    "set_1 = set(A)\n",
    "set_2 = set(B)\n",
    "\n",
    "intersection_set = set_1 & set_2\n",
    "answer = list(intersection_set)\n",
    "\n",
    "answer.sort()\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53b1236a",
   "metadata": {},
   "source": [
    "# Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "69f65eae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A dictionary stores element as keys and values pairs.\n",
    "# The key is like an index, it's is always unique and immutable.\n",
    "# The values are the objects that contain information.\n",
    "# Values are accessed using their keys.\n",
    "# Each key is followed by a value separated by a colon.\n",
    "# The values can be immutable, mutable, and duplicates.\n",
    "# Each key and value pair is separated by a comma enclosed inside curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "e0ecf866",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'USD'"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a dictionary\n",
    "d = {\"India\" : \"INR\", \"USA\" : \"USD\", \"France\" : \"Euros\"}\n",
    "\n",
    "# Access value using keys\n",
    "d[\"USA\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "a080867d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'India': 'INR', 'USA': '$', 'France': 'Euros'}"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Replace the value for a key in a dictionary\n",
    "\n",
    "d[\"USA\"] = \"$\"\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "3149e4d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'India': 'INR', 'USA': '$', 'France': 'Euros', 'Japan': 'Yen'}"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Insert new key value pair into a dictionary\n",
    "\n",
    "d[\"Japan\"] = \"Yen\"\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "760aa90e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'India': 'INR', 'USA': '$', 'Japan': 'Yen'}"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Deleting a key value pair\n",
    "\n",
    "del d[\"France\"]\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "46b333ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['India', 'Japan', 'USA']"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting a dictionary\n",
    "# sort based on key\n",
    "sorted(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "8cd993a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['$', 'INR', 'Yen']"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "ccc8b84f",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'dict_values' object has no attribute 'sort'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_5088/205524865.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0md\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'dict_values' object has no attribute 'sort'"
     ]
    }
   ],
   "source": [
    "d.values().sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "b31d569d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['INR', 'USD', 'Euros'])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# values() Method\n",
    "\n",
    "d = {\"India\" : \"INR\", \"USA\" : \"USD\", \"France\" : \"Euros\"}\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "9076c281",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['India', 'USA', 'France'])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Keys() Method\n",
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "465f74f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'India': 'INR', 'USA': '$', 'France': 'Euros'}"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Update() Method\n",
    "\n",
    "d.update({'USA':'$'})\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "3840efac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'India': 'INR', 'USA': '$', 'Japan': 'Yen', 'ABC': '$'}"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.update({'ABC':'$'})\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "2654c904",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {1: \"A\" , 2:\"B\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "aa5d9b7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "7d022efe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([1, 2])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "8423251d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['A', 'B'])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "91854788",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(d.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "a134d937",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "b178ff55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([(1, 'A'), (2, 'B')])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# returns key, value as tuples in a list\n",
    "d.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "7675fb20",
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = (1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "9aaf3e41",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = list(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "939557a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "2ccb9982",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = \"qwertyuioppasfdhdjfflhs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "7f20bb77",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "list = list(letters)\n",
    "tup = tuple(letters)\n",
    "set = set(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "a5c07b6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pythons syntax is easy to learn & Pythons syntax is very clear\n",
      "list  ['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'p', 'a', 's', 'f', 'd', 'h', 'd', 'j', 'f', 'f', 'l', 'h', 's']\n",
      "tuple ('q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'p', 'a', 's', 'f', 'd', 'h', 'd', 'j', 'f', 'f', 'l', 'h', 's')\n",
      "set {'w', 't', 'u', 'a', 'i', 'r', 'l', 'f', 'h', 'q', 'o', 'p', 'j', 's', 'd', 'e', 'y'}\n"
     ]
    }
   ],
   "source": [
    "print(str)\n",
    "print(\"list \" , list)\n",
    "print(\"tuple\" , tup)\n",
    "print(\"set\" , set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a2bac84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write code to fetch the profession of the employee with Employee id - 104 from an employee input given in the form of a dictionary where key represent employ id and values represent the name, age, and profession (in the same order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a1d4280",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input : Employee_data = { 101:['Shiva', 24, 'Content Strategist'] ,102:['Udit',25,'Content Strategist'], 103:['Sonam', 28,'Sr Manager'], 104:['Ansari',29,'Product Lead' ],105:['Huzefa',32,'Project Manager' ]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7b3d9b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_dict =  { 101:['Shiva', 24, 'Content Strategist'] ,102:['Udit',25,'Content Strategist'], 103:['Sonam', 28,'Sr Manager'], 104:['Ansari',29,'Product Lead' ],105:['Huzefa',32,'Project Manager' ]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25ca045a",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_dict[104][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49343459",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  empty dictionary.\n",
    "d = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8431fbe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# methods to create a dictionary.\n",
    "\n",
    "d = {'a':1, 'b':2}\n",
    "d = dict(a=1, b=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40cfb183",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_1 = {\"Python\": 40, \"R\": 45}\n",
    "del dict_1['R']\n",
    "dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "fece8fee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NA'"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the value of a key ‘Label’ which is not a part of the dictionary, in such a way that Python doesn't hit an error. If the key does not exist in the dictionary, Python should return 'NA'.\n",
    "\n",
    "input_dict={'Name': 'Monty', 'Profession': 'Singer' }\n",
    "input_dict.get('Label', 'NA')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "c845e4b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty'"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_dict.get('Name', 'NA')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "a895d2f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NA'"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_dict.get('Aba', 'NA')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4665510c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a SORTED list of all values from the dictionary\n",
    "\n",
    "d = {'Jack Dorsey' : 'Twitter' , 'Tim Cook' : 'Apple','Jeff Bezos' : 'Amazon' ,'Mukesh Ambani' : 'RJIO'}\n",
    "\n",
    "l =  list(input_dict.values())\n",
    "l.sort()\n",
    "l\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "45991072",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swaroop's address is swaroop@swaroopch.com\n",
      "\n",
      "There are 3 contacts in the address-book\n",
      "\n",
      "Contact Swaroop at swaroop@swaroopch.com\n",
      "Contact Larry at larry@wall.org\n",
      "Contact Matsumoto at matz@ruby-lang.org\n",
      "\n",
      "Guido's address is guido@python.org\n"
     ]
    }
   ],
   "source": [
    "\n",
    "ab = {\n",
    "    'Swaroop': 'swaroop@swaroopch.com',\n",
    "    'Larry': 'larry@wall.org',\n",
    "    'Matsumoto': 'matz@ruby-lang.org',\n",
    "    'Spammer': 'spammer@hotmail.com'\n",
    "}\n",
    "\n",
    "print(\"Swaroop's address is\", ab['Swaroop'])\n",
    "\n",
    "# Deleting a key-value pair\n",
    "del ab['Spammer']\n",
    "\n",
    "print('\\nThere are {} contacts in the address-book\\n'.format(len(ab)))\n",
    "\n",
    "for name, address in ab.items():\n",
    "    print('Contact {} at {}'.format(name, address))\n",
    "\n",
    "# Adding a key-value pair\n",
    "ab['Guido'] = 'guido@python.org'\n",
    "\n",
    "if 'Guido' in ab:\n",
    "    print(\"\\nGuido's address is\", ab['Guido'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "ae196c0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item 0 is apple\n",
      "Item 1 is mango\n",
      "Item 2 is carrot\n",
      "Item 3 is banana\n",
      "Item -1 is banana\n",
      "Item -2 is carrot\n",
      "Character 0 is s\n",
      "Item 1 to 3 is ['mango', 'carrot']\n",
      "Item 2 to end is ['carrot', 'banana']\n",
      "Item 1 to -1 is ['mango', 'carrot']\n",
      "Item start to end is ['apple', 'mango', 'carrot', 'banana']\n",
      "characters 1 to 3 is wa\n",
      "characters 2 to end is aroop\n",
      "characters 1 to -1 is waroo\n",
      "characters start to end is swaroop\n"
     ]
    }
   ],
   "source": [
    "# slicing \n",
    "\n",
    "shoplist = ['apple', 'mango', 'carrot', 'banana']\n",
    "name = 'swaroop'\n",
    "\n",
    "# Indexing or 'Subscription' operation #\n",
    "print('Item 0 is', shoplist[0])\n",
    "print('Item 1 is', shoplist[1])\n",
    "print('Item 2 is', shoplist[2])\n",
    "print('Item 3 is', shoplist[3])\n",
    "print('Item -1 is', shoplist[-1])\n",
    "print('Item -2 is', shoplist[-2])\n",
    "print('Character 0 is', name[0])\n",
    "\n",
    "# Slicing on a list #\n",
    "print('Item 1 to 3 is', shoplist[1:3])\n",
    "print('Item 2 to end is', shoplist[2:])\n",
    "print('Item 1 to -1 is', shoplist[1:-1])\n",
    "print('Item start to end is', shoplist[:])\n",
    "\n",
    "# Slicing on a string #\n",
    "print('characters 1 to 3 is', name[1:3])\n",
    "print('characters 2 to end is', name[2:])\n",
    "print('characters 1 to -1 is', name[1:-1])\n",
    "print('characters start to end is', name[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "83e0998c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'mango', 'carrot', 'banana']"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shoplist[::1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "9d3c5c90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'carrot']"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shoplist[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "c901fc82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana']"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shoplist[::3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "de443ade",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'carrot', 'mango', 'apple']"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shoplist[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "aeab4864",
   "metadata": {},
   "outputs": [],
   "source": [
    "# refernces\n",
    "\n",
    "# When you create an object and assign it to a variable, the variable only refers to the object and does not represent the object itself! \n",
    "# That is, the variable name points to that part of your computer's memory where the object is stored. \n",
    "# This is called binding the name to the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "f9875f5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simple Assignment\n",
      "shoplist is ['mango', 'carrot', 'banana']\n",
      "mylist is ['mango', 'carrot', 'banana']\n",
      "Copy by making a full slice\n",
      "shoplist is ['mango', 'carrot', 'banana']\n",
      "mylist is ['carrot', 'banana']\n"
     ]
    }
   ],
   "source": [
    "print('Simple Assignment')\n",
    "shoplist = ['apple', 'mango', 'carrot', 'banana']\n",
    "# mylist is just another name pointing to the same object!\n",
    "mylist = shoplist\n",
    "\n",
    "# I purchased the first item, so I remove it from the list\n",
    "del shoplist[0]\n",
    "\n",
    "print('shoplist is', shoplist)\n",
    "print('mylist is', mylist)\n",
    "# Notice that both shoplist and mylist both print\n",
    "# the same list without the 'apple' confirming that\n",
    "# they point to the same object\n",
    "\n",
    "print('Copy by making a full slice')\n",
    "# Make a copy by doing a full slice\n",
    "mylist = shoplist[:]\n",
    "# Remove first item\n",
    "del mylist[0]\n",
    "\n",
    "print('shoplist is', shoplist)\n",
    "print('mylist is', mylist)\n",
    "# Notice that now the two lists are different"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c9badf3",
   "metadata": {},
   "source": [
    "# Practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "d196f352",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "103\n"
     ]
    }
   ],
   "source": [
    "# Print a random integer between 100 and 135\n",
    "\n",
    "from random import seed\n",
    "from random import randint\n",
    "\n",
    "print(randint(100,135))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "53389934",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Create a list consisting of first 10 even numbers.\n",
    "l=[]\n",
    "for i in range(2,22,2):\n",
    "    l.append(i)\n",
    "print(l)\n",
    "print(len(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "d17f2ffe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list in the following manner: [birthyear, firstname, birthdate, lastname]\n",
    "l=[2006,'ABC',19,'XYZ']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "01804a31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Alex', 'Cody'], ['Mathematics,English'], [97, 95], [89, 92]]\n"
     ]
    }
   ],
   "source": [
    "#  Create a nested list which consist of 2 students and their scores in mathematics and english:\n",
    "\n",
    "# Alex scores 97 and 95 in mathematics and english respectively,\n",
    "#Cody scores 89 and 92 in mathematics and english respectively.\n",
    "\n",
    "# The list should be such that it first stores the name of students followed by the subjects and then their scores in nested lists.\n",
    "\n",
    "l=[['Alex','Cody'],['Mathematics,English'],[97,95],[89,92]]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "2a2be974",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Given below is a list, find out whether is has the letter 'k' in it and print the result as true or false.\n",
    "\n",
    "list3=[1,2,'r',7,'k',6,'o','h','d',5,9]\n",
    "char='k'\n",
    "\n",
    "# print the result:\n",
    "print(char in list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "2ddfdee2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "world\n"
     ]
    }
   ],
   "source": [
    "# In the tuple given below, print the 3rd element.\n",
    "\n",
    "tuple1=(1,'hello','world','567')\n",
    "\n",
    "# Print the 3rd element:\n",
    "print(tuple1[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "a77338e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 25, 54, 67, 100]\n"
     ]
    }
   ],
   "source": [
    "# Given below is a tuple. Sort the tuple and print the result.\n",
    "\n",
    "tuple2=(1,25,67,100,3,54)\n",
    "\n",
    "# Sort the tuple:\n",
    "tuple3=sorted(tuple2)\n",
    "\n",
    "# Print the result:\n",
    "print(tuple3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f396f77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7}\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Given below is a list, convert into a set and print the output also print the length of the set.\n",
    "\n",
    "list4=[1,2,4,6,3,2,5,4,7,4,6,5,3,2,2,1]\n",
    "\n",
    "# Convert the list into set:\n",
    "set1=set(list4)\n",
    "\n",
    "# Print the result:\n",
    "print(set1)\n",
    "\n",
    "# Print the length of the set:\n",
    "print(len(set1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "996341fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "{2, 3, 5}\n",
      "{1, 6, 7}\n",
      "{1, 4, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "# Given below are two sets, perform the operations given below:\n",
    "# Print their union\n",
    "# Print their intersection\n",
    "# Print their difference\n",
    "# Print their symmetric difference\n",
    "\n",
    "a={1,2,3,5,6,7}\n",
    "b={4,5,8,9,2,3}\n",
    "\n",
    "# Print their union:\n",
    "print(a.union(b))\n",
    "\n",
    "# Print their intersection:\n",
    "print(a.intersection(b))\n",
    "\n",
    "# Print their difference:\n",
    "print(a.difference(b))\n",
    "\n",
    "# Print their symmetric difference:\n",
    "print(a^b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2bed64a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dictionary that stores the names and roll numbers of 5 students as given below:\n",
    "\n",
    "# Sam, 21\n",
    "# Cody, 12\n",
    "# Addy, 3\n",
    "# Zach, 45\n",
    "# Amy, 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a616a849",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sam': 21, 'Cody': 12, 'Addy': 3, 'Zach': 45, 'Amy': 6}\n"
     ]
    }
   ],
   "source": [
    "dict1={'Sam':21, 'Cody':12, 'Addy':3, 'Zach':45, 'Amy':6}\n",
    "\n",
    "# Print the result:\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "57fe06f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update the roll number:\n",
    "dict1['Zach']=47"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "09fbf0e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update the roll number:\n",
    "dict1.update({'Sam': 47})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "15249f67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sam': 47, 'Cody': 12, 'Addy': 3, 'Zach': 47, 'Amy': 6}\n"
     ]
    }
   ],
   "source": [
    "# Print the new dictionary:\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fa988c7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Addy', 'Amy', 'Cody', 'Sam', 'Zach']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort the dictionary according to roll number.\n",
    "\n",
    "# Sort and print the students roll number wise in ascending order:\n",
    "sorted(dict1)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}