Part - 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9e8a326a",
   "metadata": {},
   "source": [
    "# String\n",
    "Any sequence of characters within either single quotes or double quotes is considered as a String.\n",
    "\n",
    "    Syntax:\n",
    "    s='nikhil'\n",
    "    s=\"nikhil\"\n",
    "    \n",
    "- Python strings are immutable, which means they cannot be altered after they are created.\n",
    "\n",
    "Note: In most of other languges like C, C++,Java, a single character with in single quotes is treated as char data type value. But in Python we are not having char data type. Hence it is treated as\n",
    "String only.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1ad39c7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Eg:\n",
    "ch='n'\n",
    "type(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59c5b296",
   "metadata": {},
   "source": [
    "## How to define multi-line String literals:\n",
    "We can define multi-line String literals by using triple single or double quotes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df59abbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhil\n",
      "    is a good boy\n"
     ]
    }
   ],
   "source": [
    "# Eg\n",
    "s = '''nikhil\n",
    "    is a good boy'''\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c814f35",
   "metadata": {},
   "source": [
    "#### We can also use triple quotes to use single quotes or double quotes as symbol inside String literal.\n",
    "\n",
    "    Eg:\n",
    "    s='This is ' single quote symbol' ==>invalid\n",
    "    s='This is \\' single quote symbol' ==>valid\n",
    "    s=\"This is ' single quote symbol\"====>valid\n",
    "    s='This is \" double quotes symbol' ==>valid\n",
    "    s='The \"Python Notes\" by 'durga' is very helpful' ==>invalid\n",
    "    s=\"The \"Python Notes\" by 'durga' is very helpful\"==>invalid\n",
    "    s='The \\\"Python Notes\\\" by \\'durga\\' is very helpful' ==>valid\n",
    "    s='''The \"Python Notes\" by 'durga' is very helpful''' ==>valid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ba35e61",
   "metadata": {},
   "source": [
    "## How to access characters of a String:\n",
    "We can access characters of a string by using the following ways.\n",
    "1. By using index\n",
    "2. By using slice operator\n",
    "\n",
    "## 1. By using index:\n",
    "Python supports both +ve and -ve index.\n",
    "- +ve index means left to right(Forward direction)\n",
    "- -ve index means right to left(Backward direction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7032b829",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ex\n",
    "s = 'nikhil'\n",
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "304736db",
   "metadata": {},
   "source": [
    "#### Note: If we are trying to access characters of a string with out of range index then we will get error saying : IndexError\n",
    "\n",
    "#### Q. Write a program to accept some string from the keyboard and display its characters by index wise(both positive and nEgative index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "63ea6563",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the string: Nikhil\n",
      "The character present at positive index 0 and at nEgative index -6 is N\n",
      "The character present at positive index 1 and at nEgative index -5 is i\n",
      "The character present at positive index 2 and at nEgative index -4 is k\n",
      "The character present at positive index 3 and at nEgative index -3 is h\n",
      "The character present at positive index 4 and at nEgative index -2 is i\n",
      "The character present at positive index 5 and at nEgative index -1 is l\n"
     ]
    }
   ],
   "source": [
    "s = input('Enter the string: ')\n",
    "i = 0\n",
    "for x in s:\n",
    "    print(\"The character present at positive index {} and at nEgative index {} is {}\".format(i,i-len(s),x)) \n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7980c835",
   "metadata": {},
   "source": [
    "## 2. Accessing characters by using slice operator:\n",
    "Syntax: \n",
    "    \n",
    "    s[beginindex : endindex : step]\n",
    "\n",
    "    beginindex:From where we have to consider slice(substring)\n",
    "    endindex: We have to terminate the slice(substring) at endindex-1\n",
    "    step: incremented value\n",
    "    \n",
    "Note: If we are not specifying bEgin index then it will consider from bEginning of the string. If we are not specifying end index then it will consider up to end of the string The default value for step is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ddc80143",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!!!egaugnaL ysae yrev si nohtyP'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"Python is very easy Language!!!\"\n",
    "#s[1:7:1] \n",
    "\n",
    "s[::-1]"
   ]
  },
  {
   "cell_type": "raw",
   "id": "23a4baa6",
   "metadata": {},
   "source": [
    "s[1:7] ---> 'ython'\n",
    "s[1:7:2] ---> 'yhn'\n",
    "s[:7] ---> 'Python '\n",
    "s[7:] ---> 'is very easy Language!!!'\n",
    "s[::] ---> 'Python is very easy Language!!!'\n",
    "s[:] ---> 'Python is very easy Language!!!!'\n",
    "s[::-1] ---> ''!!!egaugnaL ysae yrev si nohtyP'' "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6ed1393",
   "metadata": {},
   "source": [
    "### Behaviour of slice operator:\n",
    "\n",
    "    s[begin:end:step]\n",
    "\n",
    "    step value can be either +ve or –ve\n",
    "- if +ve then it should be forward direction(left to right) and we have to consider bEgin to end-1\n",
    "- if -ve then it should be backward direction(right to left) and we have to consider bEgin to end+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0be3e9f",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "- In the backward direction if end value is -1 then result is always empty.\n",
    "- In the forward direction if end value is 0 then result is always empty. \n",
    "\n",
    "#### In forward direction:\n",
    "\n",
    "- default value for begin: 0\n",
    "- default value for end: length of string\n",
    "- default value for step: +1\n",
    "\n",
    "#### In backward direction:\n",
    "- default value for begin: -1\n",
    "- default value for end: -(length of string+1)\n",
    "#### Note: \n",
    "Either forward or backward direction, we can take both +ve and -ve values for begin and\n",
    "end index.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a620ff19",
   "metadata": {},
   "source": [
    "A string in python can be sliced for getting a part of the string.\n",
    "- consider the following string:-\n",
    "\n",
    "    ------>012345\n",
    "   name = 'nikhil'\n",
    "        -6-5-4-3-2-1<------\n",
    "        \n",
    "==> length = 6\n",
    "\n",
    "The index is a string starts from 0 to (length -1) in python.\n",
    "We use the following syntax:\n",
    "\n",
    "name = prakriti\n",
    "\n",
    "sl ==> name[index_start : ind_end : step value]\n",
    "  sl[0:3] returns \"pra\"\n",
    "  sl[1:3] returns \"ra\"\n",
    "  \n",
    "- NEGATIVE INDEXING\n",
    "  Negative indices can also be used as shown in the figure above -1 corresponds to the (length -1) index, -2 to (length -2).\n",
    "\n",
    "- Slicing with skip value\n",
    "  we can provide a skip value as a part of our slice like this:-\n",
    "\n",
    "name = \"prakriti\"\n",
    "name[1:8:2] ---> 'rkii'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74fd6ce5",
   "metadata": {},
   "source": [
    "### Mathematical Operators for String:\n",
    "We can apply the following mathematical operators for Strings.\n",
    "\n",
    "    1. + operator for concatenation\n",
    "    2. * operator for repetition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2eb0dff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhilyadav\n",
      "nikhilnikhil\n"
     ]
    }
   ],
   "source": [
    "print(\"nikhil\"+\"yadav\") \n",
    "print(\"nikhil\"*2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "780c0c2f",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "1. To use + operator for Strings, compulsory both arguments should be str type\n",
    "2. To use * operator for Strings, compulsory one argument should be str and other argument\n",
    "should be int\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4e21a77",
   "metadata": {},
   "source": [
    "#### len() in-built function:\n",
    "We can use len() function to find the number of characters present in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b8674858",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# Eg\n",
    "s = 'prakriti'\n",
    "print(len(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97f38f9c",
   "metadata": {},
   "source": [
    "#### Q. Write a program to access each character of string in forward and backward direction by using while loop?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "eb72787b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Forward direction\n",
      "P y t h o n   i s   v e r y   e a s y   L a n g u a g e   ! ! ! \n",
      "Backward direction\n",
      "! ! !   e g a u g n a L   y s a e   y r e v   s i   n o h t y P "
     ]
    }
   ],
   "source": [
    "s=\"Python is very easy Language !!!\"\n",
    "n=len(s)\n",
    "i=0\n",
    "print(\"Forward direction\")\n",
    "while i<n:\n",
    "    print(s[i],end=' ')\n",
    "    i +=1\n",
    "print(\"\\nBackward direction\")\n",
    "i=-1\n",
    "while i>=-n:\n",
    "    print(s[i],end=' ')\n",
    "    i=i-1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fbf8c312",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Forward direction\n",
      "P y t h o n   i s   v e r y   e a s y   L a n g u a g e   ! ! ! \n",
      "Forward direction\n",
      "P y t h o n   i s   v e r y   e a s y   L a n g u a g e   ! ! ! \n",
      "Backward direction\n",
      "! ! !   e g a u g n a L   y s a e   y r e v   s i   n o h t y P "
     ]
    }
   ],
   "source": [
    "# Alternative ways:\n",
    "s=\"Python is very easy Language !!!\"\n",
    "print(\"Forward direction\")\n",
    "for i in s:\n",
    "    print(i,end=' ')\n",
    "print(\"\\nForward direction\")\n",
    "for i in s[::]:\n",
    "    print(i,end=' ')\n",
    "print(\"\\nBackward direction\")\n",
    "for i in s[::-1]:\n",
    "    print(i,end=' ') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13cb2ba1",
   "metadata": {},
   "source": [
    "## Checking Membership:\n",
    "We can check whether the character or string is the member of another string or not by using in and not in operators.\n",
    "\n",
    "    s='nikhil'\n",
    "    print('n' in s) #True\n",
    "    print('z' in s) #False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "840904ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter string: Nikhil\n",
      "Enter sub string: i\n",
      "i is found in main string\n"
     ]
    }
   ],
   "source": [
    "# Program:\n",
    "s=input(\"Enter string: \")\n",
    "subs=input(\"Enter sub string: \")\n",
    "if subs in s:\n",
    "    print(subs,\"is found in main string\")\n",
    "else: \n",
    "    print(subs,\"is not found in main string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d35d7d20",
   "metadata": {},
   "source": [
    "## Removing spaces from the string:\n",
    "We can use the following 3 methods\n",
    "1. rstrip()===>To remove spaces at right hand side\n",
    "2. lstrip()===>To remove spaces at left hand side\n",
    "3. strip() ==>To remove spaces both sides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cfbac41c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhil\n",
      "   nikhil\n",
      "nikhil     \n",
      "****yadav\n",
      "yadav****\n",
      "yadav\n",
      "yadav\n"
     ]
    }
   ],
   "source": [
    "# lstrip\n",
    "# rstrip\n",
    "# strip\n",
    "\n",
    "a = \"   nikhil     \"\n",
    "print(a.strip())\n",
    "print(a.rstrip())\n",
    "print(a.lstrip())\n",
    "\n",
    "b = \"****yadav****\"\n",
    "\n",
    "print(b.rstrip(\"*\"))\n",
    "print(b.lstrip(\"*\"))\n",
    "print(b.strip(\"*\"))\n",
    "c = b.strip(\"*\")\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ee4541",
   "metadata": {},
   "source": [
    "### Finding Substrings:\n",
    "We can use the following 4 methods\n",
    "\n",
    "#### For forward direction:\n",
    "- find()\n",
    "- index()\n",
    "#### For backward direction:\n",
    "- rfind()\n",
    "- rindex()\n",
    "### 1. find():\n",
    "\n",
    "    s.find(substring)\n",
    "\n",
    "Returns index of first occurrence of the given substring. If it is not available then we will get -1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "420bf5d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is - 7\n",
      "Nik - 0\n",
      "ML - -1\n"
     ]
    }
   ],
   "source": [
    "# Eg\n",
    "s = \"Nikhil is a good boy\"\n",
    "print('is -',s.find('is'))\n",
    "print('Nik -',s.find('Nik'))\n",
    "print('ML -',s.find('ML'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dad2a1d",
   "metadata": {},
   "source": [
    "#### Note: By default find() method can search total string. We can also specify the boundaries to search.\n",
    "\n",
    "    s.find(substring,begin,end)\n",
    "    \n",
    "- It will always search from begin index to end-1 index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "98e2344c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "7\n",
      "9\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s=\"Nikhilyadav\" \n",
    "print(s.find('a'))\n",
    "print(s.find('a',7,15)) \n",
    "print(s.find('a',8,15))\n",
    "print(s.find('z',7,15))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9abb14d",
   "metadata": {},
   "source": [
    "### index() method:\n",
    "index() method is exactly same as find() method except that if the specified substring is not available then we will get ValueError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "34e8761d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter main string: Prakriti\n",
      "Enter sub string: n\n",
      "substring not found\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s=input(\"Enter main string: \") \n",
    "subs=input(\"Enter sub string: \") \n",
    "try: \n",
    "    n=s.index(subs) \n",
    "except ValueError: \n",
    "    print(\"substring not found\") \n",
    "else: \n",
    "    print(\"substring found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57af2016",
   "metadata": {},
   "source": [
    "#### Q. Program to display all positions of substring in a given main string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "09673b6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter main string: Nikhil\n",
      "Enter sub string: ik\n",
      "Found at position 1\n"
     ]
    }
   ],
   "source": [
    "s=input(\"Enter main string: \") \n",
    "subs=input(\"Enter sub string: \") \n",
    "flag=False \n",
    "pos=-1 \n",
    "n=len(s) \n",
    "while True: \n",
    "    pos=s.find(subs,pos+1,n) \n",
    "    if pos==-1: \n",
    "        break \n",
    "    print(\"Found at position\",pos) \n",
    "    flag=True \n",
    "if flag==False: \n",
    "    print(\"Not Found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9866bd53",
   "metadata": {},
   "source": [
    "### Counting substring in the given String:\n",
    "We can find the number of occurrences of substring present in the given string by using count() method.\n",
    "\n",
    "    1. s.count(substring) ==> It will search through out the string\n",
    "    2. s.count(substring, begin, end) ===> It will search from begin index to end-1 index\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cd6139aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Eg\n",
    "s = 'Nikhil Yadav from Delhi'\n",
    "print(s.count('a'))\n",
    "print(s.count('hi'))\n",
    "print(s.count('a',9,15))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12f11e66",
   "metadata": {},
   "source": [
    "### Replacing a string with another string:\n",
    "\n",
    "    s.replace(oldstring,newstring)\n",
    "\n",
    "inside s, every occurrence of oldstring will be replaced with newstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "cec1f822",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning Python is very easy\n"
     ]
    }
   ],
   "source": [
    "# Eg1:\n",
    "s=\"Learning Python is very difficult\"\n",
    "s1=s.replace(\"difficult\",\"easy\")\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "38de70f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bbbbbbbbbbbbbb\n"
     ]
    }
   ],
   "source": [
    "# Eg2: All occurrences will be replaced\n",
    "s=\"ababababababab\"\n",
    "s1=s.replace(\"a\",\"b\")\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a033ecd2",
   "metadata": {},
   "source": [
    "#### Q. String objects are immutable then how we can change the content by using replace() method.\n",
    "Once we creates string object, we cannot change the content.This non changeable behaviour is \n",
    "nothing but immutability. If we are trying to change the content by using any method, then with \n",
    "those changes a new object will be created and changes won't be happend in existing object.\n",
    "\n",
    "\n",
    "Hence with replace() method also a new object got created but existing object won't be changed.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7bc4a3ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abab is available at : 3176085975920\n",
      "bbbb is available at : 3176085975664\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s=\"abab\"\n",
    "s1=s.replace(\"a\",\"b\")\n",
    "print(s,\"is available at :\",id(s))\n",
    "print(s1,\"is available at :\",id(s1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d6cb7d8",
   "metadata": {},
   "source": [
    "In the above example, original object is available and we can see new object which was created \n",
    "because of replace() method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fbe83eb",
   "metadata": {},
   "source": [
    "### Splitting of Strings:\n",
    "We can split the given string according to specified seperator by using split() method.\n",
    "    \n",
    "    l=s.split(seperator)\n",
    "\n",
    "The default seperator is space. The return type of split() method is List\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f768d332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n",
      "02\n",
      "2018\n"
     ]
    }
   ],
   "source": [
    "# Eg2:\n",
    "s=\"22-02-2018\" \n",
    "l=s.split('-') \n",
    "for x in l: \n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c3f32fc",
   "metadata": {},
   "source": [
    "### Changing case of a String:\n",
    "We can change case of a string by using the following 4 methods.\n",
    "1. upper() ===>To convert all characters to upper case\n",
    "2. lower() ===>To convert all characters to lower case\n",
    "3. swapcase() ===>converts all lower case characters to upper case and all upper case characters to \n",
    "lower case\n",
    "4. title() ===>To convert all character to title case. i.e first character in every word should be upper \n",
    "case and all remaining characters should be in lower case.\n",
    "5. capitalize() ==>Only first character will be converted to upper case and all remaining characters \n",
    "can be converted to lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f7cffbf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PYTHON IS VERY EASY LANGUAGE\n",
      "python is very easy language\n",
      "PYTHON IS VERY eASY lANGUAGE\n",
      "Python Is Very Easy Language\n",
      "Python is very easy language\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s='python is very Easy Language'\n",
    "print(s.upper())\n",
    "print(s.lower())\n",
    "print(s.swapcase())\n",
    "print(s.title())\n",
    "print(s.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50816404",
   "metadata": {},
   "source": [
    "### Checking starting and ending part of the string:\n",
    "Python contains the following methods for this purpose\n",
    "\n",
    "    1. s.startswith(substring)\n",
    "    2. s.endswith(substring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c1ea981f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s='Python is very easy learning'\n",
    "print(s.startswith('learning'))\n",
    "print(s.endswith('learning'))\n",
    "print(s.endswith('easy'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fc6ac63",
   "metadata": {},
   "source": [
    "### To check type of characters present in a string:\n",
    "\n",
    "Python contains the following methods for this purpose.\n",
    "\n",
    "1. isalnum(): Returns True if all characters are alphanumeric( a to z , A to Z ,0 to9 )\n",
    "2. isalpha(): Returns True if all characters are only alphabet symbols(a to z,A to Z)\n",
    "3. isdigit(): Returns True if all characters are digits only( 0 to 9)\n",
    "4. islower(): Returns True if all characters are lower case alphabet symbols\n",
    "5. isupper(): Returns True if all characters are upper case aplhabet symbols\n",
    "6. istitle(): Returns True if string is in title case\n",
    "7. isspace(): Returns True if string contains only spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3093af72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "print('Nikhil9027'.isalnum()) #True\n",
    "print('Nikhil90'.isalpha()) #False\n",
    "print('nikhil'.isalpha()) #True\n",
    "print('prakriti'.isdigit()) #False\n",
    "print('902780'.isdigit()) #True\n",
    "print('abc'.islower()) #True\n",
    "print('Abc'.islower()) #False\n",
    "print('abc123'.islower()) #True\n",
    "print('ABC'.isupper()) #True\n",
    "print('Learning python is Easy'.istitle()) #False\n",
    "print('Learning Python Is Easy'.istitle()) #True\n",
    "print(' '.isspace()) #True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f024f80e",
   "metadata": {},
   "source": [
    "### Formatting the Strings:\n",
    "We can format the strings with variable values by using replacement operator {} and format() \n",
    "method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "74b24a46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhil's salary is 10000 and his age is 20\n",
      "nikhil's salary is 10000 and his age is 20\n",
      "nikhil's salary is 10000 and his age is 20\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "name='nikhil'\n",
    "salary=10000\n",
    "age=20\n",
    "print(\"{}'s salary is {} and his age is {}\".format(name,salary,age))\n",
    "print(\"{0}'s salary is {1} and his age is {2}\".format(name,salary,age))\n",
    "print(\"{x}'s salary is {y} and his age is {z}\".format(z=age,y=salary,x=name))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "773d5022",
   "metadata": {},
   "source": [
    "### Important Programs regarding String Concept\n",
    "\n",
    "#### Q1. Write a program to reverse the given String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c329a5b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Some String:Prakriti\n",
      "itirkarP\n",
      "Enter Some String:Nikhil\n",
      "lihkiN\n",
      "Enter Some String:Akhil\n",
      "lihkA\n"
     ]
    }
   ],
   "source": [
    "# input: Nikhil\n",
    "# output:lihkiN\n",
    "\n",
    "# 1st Way:\n",
    "s=input(\"Enter Some String:\")\n",
    "print(s[::-1])\n",
    "\n",
    "# 2nd Way:\n",
    "s=input(\"Enter Some String:\")\n",
    "print(''.join(reversed(s)))\n",
    "\n",
    "# 3rd Way:\n",
    "s=input(\"Enter Some String:\")\n",
    "i=len(s)-1\n",
    "target=''\n",
    "while i>=0:\n",
    "    target=target+s[i]\n",
    "    i=i-1\n",
    "print(target)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29dd9000",
   "metadata": {},
   "source": [
    "#### Q2. Write a program for the following requirement "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "38cfb304",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Some String:a4b3c2\n",
      "aaaabbbcc\n"
     ]
    }
   ],
   "source": [
    "# input: a4b3c2\n",
    "# output: aaaabbbcc\n",
    "\n",
    "s=input(\"Enter Some String:\") \n",
    "output='' \n",
    "for x in s: \n",
    "    if x.isalpha(): \n",
    "        output=output+x \n",
    "        previous=x \n",
    "    else: \n",
    "        output=output+previous*(int(x)-1) \n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74b6b197",
   "metadata": {},
   "source": [
    "### Formatting Date values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c319ed47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's now:08/01/2023 14:34:57\n"
     ]
    }
   ],
   "source": [
    "import datetime \n",
    "\n",
    "date=datetime.datetime.now() \n",
    "print(\"It's now:{:%d/%m/%Y %H:%M:%S}\".format(date))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6205877b",
   "metadata": {},
   "source": [
    "### Escape Characters\n",
    "\n",
    "    Code\tResult\n",
    "    \\'\t--> Single Quote\t\n",
    "    \\\\\t--> Backslash\t\n",
    "    \\n\t--> New Line\t\n",
    "    \\r\t--> Carriage Return\t\n",
    "    \\t\t--> Tab\t\n",
    "    \\b\t--> Backspace\t\n",
    "    \\f\t--> Form Feed\t\n",
    "    \\ooo\t--> Octal value\t\n",
    "    \\xhh\t--> Hex value\t\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "234c616e",
   "metadata": {},
   "source": [
    "### All String Methods\n",
    "\n",
    "        Method ----> Description\n",
    "    \n",
    "    capitalize() ----> Converts the first character to upper case\n",
    "    casefold() ----> Converts string into lower case\n",
    "    center() ----> Returns a centered string\n",
    "    count() ----> Returns the number of times a specified value occurs in a string\n",
    "    encode() ----> Returns an encoded version of the string\n",
    "    endswith() ----> Returns true if the string ends with the specified value\n",
    "    expandtabs() ----> Sets the tab size of the string\n",
    "    find() ----> Searches the string for a specified value and returns the position of where it was found\n",
    "    format() ----> Formats specified values in a string\n",
    "    format_map() ----> Formats specified values in a string\n",
    "    index() ----> Searches the string for a specified value and returns the position of where it was found\n",
    "    isalnum() ----> Returns True if all characters in the string are alphanumeric\n",
    "    isalpha() ----> Returns True if all characters in the string are in the alphabet\n",
    "    isdecimal() ----> Returns True if all characters in the string are decimals\n",
    "    isdigit() ----> Returns True if all characters in the string are digits\n",
    "    isidentifier() ----> Returns True if the string is an identifier\n",
    "    islower() ----> Returns True if all characters in the string are lower case\n",
    "    isnumeric() ----> Returns True if all characters in the string are numeric\n",
    "    isprintable() ----> Returns True if all characters in the string are printable\n",
    "    isspace() ----> Returns True if all characters in the string are whitespaces\n",
    "    istitle() ----> Returns True if the string follows the rules of a title\n",
    "    isupper() ----> Returns True if all characters in the string are upper case\n",
    "    join() ----> Joins the elements of an iterable to the end of the string\n",
    "    ljust() ----> Returns a left justified version of the string\n",
    "    lower() ----> Converts a string into lower case\n",
    "    lstrip() ----> Returns a left trim version of the string\n",
    "    maketrans() ----> Returns a translation table to be used in translations\n",
    "    partition() ----> Returns a tuple where the string is parted into three parts\n",
    "    replace() ----> Returns a string where a specified value is replaced with a specified value\n",
    "    rfind() ----> Searches the string for a specified value and returns the last position of where it was found\n",
    "    rindex() ----> Searches the string for a specified value and returns the last position of where it was found\n",
    "    rjust() ----> Returns a right justified version of the string\n",
    "    rpartition() ----> Returns a tuple where the string is parted into three parts\n",
    "    rsplit() ----> Splits the string at the specified separator, and returns a list\n",
    "    rstrip() ----> Returns a right trim version of the string\n",
    "    split() ----> Splits the string at the specified separator, and returns a list\n",
    "    splitlines() ----> Splits the string at line breaks and returns a list\n",
    "    startswith() ----> Returns true if the string starts with the specified value\n",
    "    strip() ----> Returns a trimmed version of the string\n",
    "    swapcase() ----> Swaps cases, lower case becomes upper case and vice versa\n",
    "    title() ----> Converts the first character of each word to upper case\n",
    "    translate() ----> Returns a translated string\n",
    "    upper() ----> Converts a string into upper case\n",
    "    zfill() ----> Fills the string with a specified number of 0 values at the beginning\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d1844a",
   "metadata": {},
   "source": [
    "## List Data Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe68f505",
   "metadata": {},
   "source": [
    "If we want to represent a group of individual objects as a single entity where insertion \n",
    "order preserved and duplicates are allowed, then we should go for List.\n",
    "\n",
    "- insertion order preserved.\n",
    "- duplicate objects are allowed\n",
    "- heterogeneous objects are allowed.\n",
    "- List is dynamic because based on our requirement we can increase the size and decrease the size.\n",
    "- In List the elements will be placed within square brackets and with comma seperator.\n",
    "\n",
    "We can differentiate duplicate elements by using index and we can preserve insertion \n",
    "order by using index. Hence index will play very important role.\n",
    "Python supports both positive and negative indexes. +ve index means from left to right where as negative index means right to left\n",
    "\n",
    "        -6  -5  -4  -3  -2  -1 <----\n",
    "        [10,\"A\",\"B\",20, 30, 10] \n",
    "    ----> 0   1   2   3   4   5\n",
    "\n",
    "List objects are mutable.i.e we can change the content.\n",
    "\n",
    "### Creation of List Objects:\n",
    "#### 1. We can create empty list object as follows...\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e72ee8c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "lst=[] \n",
    "print(lst) \n",
    "print(type(lst)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4ae7e6",
   "metadata": {},
   "source": [
    "#### 2. If we know elements already then we can create list as follows\n",
    "    \n",
    "    list=[10,20,30,40]\n",
    "    \n",
    "    \n",
    "#### 3. With dynamic input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1d1c3cd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter List: 1,2,3,2,2,34,4\n",
      "(1, 2, 3, 2, 2, 34, 4)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "lst=eval(input(\"Enter List: \")) \n",
    "print(lst) \n",
    "print(type(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "638de4cc",
   "metadata": {},
   "source": [
    "#### 4. With list() function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "66662719",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "l= list(range(0,10,2)) \n",
    "print(l) \n",
    "print(type(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0cb24358",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['N', 'i', 'k', 'h', 'i', 'l']\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s=\"Nikhil\" \n",
    "l=list(s) \n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95e4496f",
   "metadata": {},
   "source": [
    "#### 5. with split() function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8f469f70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Python', 'is', 'very', 'easy', 'Learning!!!']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "s=\"Python is very easy Learning!!!\" \n",
    "l=s.split() \n",
    "print(l) \n",
    "print(type(l)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5e84a0",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "Sometimes we can take list inside another list,such type of lists are called nested lists.\n",
    "\n",
    "    [10,20,[30,40]]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b3d430c",
   "metadata": {},
   "source": [
    "## Accessing elements of List:\n",
    "We can access elements of the list either by using index or by using slice operator(:)\n",
    "\n",
    "### 1. By using index:\n",
    "List follows zero based index. ie index of first element is zero.\n",
    "\n",
    "\n",
    "List supports both +ve and -ve indexes.\n",
    "    \n",
    "    +ve index meant for Left to Right\n",
    "    -ve index meant for Right to Left\n",
    "    \n",
    "          -4 -3 -2 -1 <----\n",
    "    list=[10,20,30,40] \n",
    "     ----> 0  1  2  3 \n",
    "\n",
    "    print(list[0]) ==> 10\n",
    "    print(list[-1]) ==> 40\n",
    "    print(list[10]) ==> IndexError: list index out of range\n",
    "\n",
    "### 2. By using slice operator:\n",
    "Syntax:\n",
    "\n",
    "    list2 = list1[start:stop:step]\n",
    "    \n",
    "    start ==> it indicates the index where slice has to start default value is 0\n",
    "    \n",
    "    stop ===> It indicates the index where slice has to end default value is max allowed index of list ie length of the list\n",
    "    \n",
    "    step ==> increment value default value is 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "7024c841",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 7]\n",
      "[5, 7, 9]\n",
      "[4, 5, 6, 7]\n",
      "[9, 7, 5]\n",
      "[5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[1,2,3,4,5,6,7,8,9,10] \n",
    "print(n[2:7:2]) \n",
    "print(n[4::2]) \n",
    "print(n[3:7]) \n",
    "print(n[8:2:-2]) \n",
    "print(n[4:100]) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d0f8cf1",
   "metadata": {},
   "source": [
    "## List vs mutability:\n",
    "Once we creates a List object,we can modify its content with same id. Hence List objects are mutable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8dda2e24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n",
      "[10, 777, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[10,20,30,40] \n",
    "print(n) \n",
    "n[1]=777 \n",
    "print(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2ac4276",
   "metadata": {},
   "source": [
    "## Traversing the elements of List:\n",
    "The sequential access of each element in the list is called traversal.\n",
    "### 1. By using while loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e4f8f345",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n=[0,1,2,3,4,5,6,7,8,9,10] \n",
    "i=0 \n",
    "while i<len(n): \n",
    "    print(n[i]) \n",
    "    i=i+1 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18f1190a",
   "metadata": {},
   "source": [
    "### 2. By using for loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e63dc80b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n=[0,1,2,3,4,5,6,7,8,9,10] \n",
    "for n1 in n: \n",
    "    print(n1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ad818cf",
   "metadata": {},
   "source": [
    "### 3. To display only even numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c68f8e05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n=[0,1,2,3,4,5,6,7,8,9,10] \n",
    "for n1 in n: \n",
    "    if n1%2==0: \n",
    "        print(n1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec2abd09",
   "metadata": {},
   "source": [
    "### 4. To display elements by index wise:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3c2bc98b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A is available at positive index:  0 and at negative index:  -3\n",
      "B is available at positive index:  1 and at negative index:  -2\n",
      "C is available at positive index:  2 and at negative index:  -1\n"
     ]
    }
   ],
   "source": [
    "l=[\"A\",\"B\",\"C\"] \n",
    "x=len(l) \n",
    "for i in range(x): \n",
    "    print(l[i],\"is available at positive index: \",i,\"and at negative index: \",i-x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "473e0b11",
   "metadata": {},
   "source": [
    "## Important functions of List:\n",
    "### I. To get information about list:\n",
    "### 1. len():\n",
    " \n",
    "     returns the number of elements present in the list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ec060680",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# Eg: \n",
    "n=[10,20,30,40]\n",
    "print(len(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a8ec011",
   "metadata": {},
   "source": [
    "### 2. count():\n",
    "It returns the number of occurrences of specified item in the list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "00619e1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "n=[1,2,2,2,2,3,3] \n",
    "print(n.count(1)) \n",
    "print(n.count(2)) \n",
    "print(n.count(3)) \n",
    "print(n.count(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f7542ab",
   "metadata": {},
   "source": [
    "### 3. index() function:\n",
    "returns the index of first occurrence of the specified item.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "de5539b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[1,2,2,2,2,3,3] \n",
    "print(n.index(1))  \n",
    "print(n.index(2)) \n",
    "print(n.index(3)) \n",
    "# print(n.index(4)) ==>ValueError: 4 is not in list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4440ca7",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "If the specified element not present in the list then we will get ValueError.Hence before index() method we have to check whether item present in the list or not by using in operator.\n",
    "\n",
    "    print( 4 in n)==>False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b5546b6",
   "metadata": {},
   "source": [
    "## II. Manipulating elements of List:\n",
    "### 1. append() function:\n",
    "We can use append() function to add item at the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0116a15c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C']\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "list=[] \n",
    "list.append(\"A\") \n",
    "list.append(\"B\") \n",
    "list.append(\"C\") \n",
    "print(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "ba2e17d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n"
     ]
    }
   ],
   "source": [
    "# Eg: To add all elements to list upto 100 which are divisible by 10\n",
    "list=[] \n",
    "for i in range(101): \n",
    "    if i%10==0: \n",
    "        list.append(i) \n",
    "print(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30db00d0",
   "metadata": {},
   "source": [
    "### 2. insert() function:\n",
    "To insert item at specified index position\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "78fa17e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 888, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "n=[1,2,3,4,5] \n",
    "n.insert(1,888) \n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "1c430b91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[999, 1, 2, 3, 4, 5, 777]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[1,2,3,4,5] \n",
    "n.insert(10,777) \n",
    "n.insert(-10,999) \n",
    "print(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "450e25e2",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "If the specified index is greater than max index then element will be inserted at last \n",
    "position. If the specified index is smaller than min index then element will be inserted at \n",
    "first position."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ea9540",
   "metadata": {},
   "source": [
    "#### Differences between append() and insert()\n",
    "\n",
    "    append() ----> In List when we add any element it will come in last i.e. it will be last element.\n",
    "\n",
    "    insert() ----> In List we can insert any element in particular index number\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32352f09",
   "metadata": {},
   "source": [
    "### 3. extend() function:\n",
    "To add all items of one list to another list\n",
    "\n",
    "    l1.extend(l2) \n",
    "     all items present in l2 will be added to l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "fab3802a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Burger', 'Pizza', 'Roll', \"Domino's\", 'Pizza Pie', 'KFC']\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "order1=[\"Burger\",\"Pizza\",\"Roll\"] \n",
    "order2=[\"Domino's\",\"Pizza Pie\",\"KFC\"] \n",
    "order1.extend(order2) \n",
    "print(order1) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c619d1d2",
   "metadata": {},
   "source": [
    "### 4. remove() function:\n",
    "We can use this function to remove specified item from the list.If the item present \n",
    "multiple times then only first occurrence will be removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "256c0109",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 10, 30]\n"
     ]
    }
   ],
   "source": [
    "n=[10,20,10,30] \n",
    "n.remove(10) \n",
    "print(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d85b3ee8",
   "metadata": {},
   "source": [
    "If the specified item not present in list then we will get ValueError\n",
    "    \n",
    "    n=[10,20,10,30] \n",
    "    n.remove(40) \n",
    "    print(n) \n",
    "    \n",
    "    ValueError: list.remove(x): x not in list "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c6c0544",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "Hence before using remove() method first we have to check specified element present in the list or not by using in operator.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6838453a",
   "metadata": {},
   "source": [
    "### 5. pop() function:\n",
    "- It removes and returns the last element of the list.\n",
    "- This is only function which manipulates list and returns some element.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "3e4cd6de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "30\n",
      "[10, 20]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[10,20,30,40] \n",
    "print(n.pop()) \n",
    "print(n.pop()) \n",
    "print(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2adf44a",
   "metadata": {},
   "source": [
    "If the list is empty then pop() function raises IndexError\n",
    "\n",
    "    Eg:\n",
    "    n=[] \n",
    "    print(n.pop()) ==> IndexError: pop from empty list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42dd662b",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "1. pop() is the only function which manipulates the list and returns some value\n",
    "2. In general we can use append() and pop() functions to implement stack datastructure by using list,which follows LIFO(Last In First Out) order.\n",
    "\n",
    "In general we can use pop() function to remove last element of the list. But we can use to remove elements based on index.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f5b0d85",
   "metadata": {},
   "source": [
    "    n.pop(index) ===> To remove and return element present at specified index.\n",
    "    n.pop() ==> To remove and return last element of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "c0d0e085",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "n=[10,20,30,40,50,60] \n",
    "print(n.pop()) \n",
    "print(n.pop(1)) \n",
    "#print(n.pop(10)) ==> IndexError: pop index out of range"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6e9c491",
   "metadata": {},
   "source": [
    "### Differences between remove() and pop()\n",
    "\n",
    "#### remove() \n",
    "1. We can use to remove special element from the List. \n",
    "2. It can’t return any value. \n",
    "3. If special element not available then we get VALUE ERROR.\n",
    "\n",
    "\n",
    "\n",
    "#### pop()\n",
    "1. We can use to remove last element from the List.\n",
    "2. It returned removed element.\n",
    "3. If List is empty then we get Error."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb2049f4",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "List objects are dynamic. i.e based on our requirement we can increase and decrease the size.\n",
    "\n",
    "    append(), insert(), extend() ===> for increasing the size/growable nature\n",
    "\n",
    "    remove(), pop() ======> for decreasing the size /shrinking nature"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "800152b8",
   "metadata": {},
   "source": [
    "## III. Ordering elements of List:\n",
    "### 1. reverse():\n",
    "We can use to reverse() order of elements of list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1f79e45c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 30, 20, 10]\n"
     ]
    }
   ],
   "source": [
    "n=[10,20,30,40] \n",
    "n.reverse()  \n",
    "print(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e388d575",
   "metadata": {},
   "source": [
    "### 2. sort() function:\n",
    "In list by default insertion order is preserved. If want to sort the elements of list according to default natural sorting order then we should go for sort() method.\n",
    "\n",
    "    For numbers ==>default natural sorting order is Ascending Order\n",
    "    For Strings ==> default natural sorting order is Alphabetical Order\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "8d547dc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 5, 10, 15, 20]\n",
      "[20, 15, 10, 5, 0]\n",
      "['Apple', 'Banana', 'Cat', 'Dog']\n"
     ]
    }
   ],
   "source": [
    "n=[20,5,15,10,0] \n",
    "n.sort() \n",
    "print(n) #[0,5,10,15,20] \n",
    "\n",
    "n=[20,5,15,10,0] \n",
    "n.sort(reverse=True) \n",
    "print(n) \n",
    "\n",
    "s=[\"Dog\",\"Banana\",\"Cat\",\"Apple\"] \n",
    "s.sort() \n",
    "print(s) #['Apple','Banana','Cat','Dog'] "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6ff611b",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "To use sort() function, compulsory list should contain only homogeneous elements. \n",
    "otherwise we will get TypeError\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67975a06",
   "metadata": {},
   "source": [
    "    Eg:\n",
    "    n=[20,10,\"A\",\"B\"] \n",
    "    n.sort() \n",
    "    print(n) \n",
    "\n",
    "    TypeError: '<' not supported between instances of 'str' and 'int' \n",
    "#### Note: \n",
    "In Python 2 if List contains both numbers and Strings then sort() function first sort numbers followed by strings But in Python 3 it is invalid.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4a60773",
   "metadata": {},
   "source": [
    "### To sort in reverse of default natural sorting order:\n",
    "We can sort according to reverse of default natural sorting order by using reverse=True \n",
    "argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47e41578",
   "metadata": {},
   "source": [
    "Eg:\n",
    "    \n",
    "    n=[40,10,30,20] \n",
    "    n.sort() \n",
    "    print(n) ==>[10,20,30,40] \n",
    "    n.sort(reverse=True) \n",
    "    print(n) ===>[40,30,20,10] \n",
    "    n.sort(reverse=False) \n",
    "    print(n) ==>[10,20,30,40] \n",
    "    \n",
    "### Aliasing and Cloning of List objects:\n",
    "The process of giving another reference variable to the existing list is called aliasing.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "b8b06635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3176118923328\n",
      "3176118923328\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x=[10,20,30,40] \n",
    "y=x \n",
    "print(id(x)) \n",
    "print(id(y)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35d893e7",
   "metadata": {},
   "source": [
    "The problem in this approach is by using one reference variable if we are changing \n",
    "content,then those changes will be reflected to the other reference variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "64a2d709",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 777, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "x=[10,20,30,40] \n",
    "y=x \n",
    "y[1]=777 \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86a83c0",
   "metadata": {},
   "source": [
    "- To overcome this problem we should go for cloning.\n",
    "- The process of creating exactly duplicate independent object is called cloning.\n",
    "- We can implement cloning by using slice operator or by using copy() function\n",
    "\n",
    "### 1. By using slice operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "4d3b72bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n",
      "[10, 777, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "x=[10,20,30,40] \n",
    "y=x[:] \n",
    "y[1]=777 \n",
    "print(x) \n",
    "print(y) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "953a5128",
   "metadata": {},
   "source": [
    "### 2. By using copy() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "a5e131a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n",
      "[10, 777, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "x=[10,20,30,40] \n",
    "y=x.copy() \n",
    "y[1]=777 \n",
    "print(x) \n",
    "print(y) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef8f369c",
   "metadata": {},
   "source": [
    "#### Q. Difference between = operator and copy() function\n",
    "= operator meant for aliasing\n",
    "\n",
    "copy() function meant for cloning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5810680c",
   "metadata": {},
   "source": [
    "## Using Mathematical operators for List Objects:\n",
    "We can use + and * operators for List objects.\n",
    "### 1. Concatenation operator(+):\n",
    "We can use + to concatenate 2 lists into a single list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "b0e3e9d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60]\n"
     ]
    }
   ],
   "source": [
    "a=[10,20,30] \n",
    "b=[40,50,60] \n",
    "c=a+b \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f9edc26",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "To use + operator compulsory both arguments should be list objects,otherwise we will get TypeError.\n",
    "\n",
    "    Eg:\n",
    "    c=a+40 ==>TypeError: can only concatenate list (not \"int\") to list\n",
    "    c=a+[40] ==>valid\n",
    "### 2. Repetition Operator(*):\n",
    "We can use repetition operator * to repeat elements of list specified number of times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "cc1d593c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 10, 20, 30, 10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x=[10,20,30] \n",
    "y=x*3 \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b12f3e01",
   "metadata": {},
   "source": [
    "### Comparing List objects\n",
    "We can use comparison operators for List objects.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "bf8e6b4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x=[\"Dog\",\"Cat\",\"Rat\"] \n",
    "y=[\"Dog\",\"Cat\",\"Rat\"] \n",
    "z=[\"DOG\",\"CAT\",\"RAT\"] \n",
    "print(x==y) \n",
    "print(x==z) \n",
    "print(x != z) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b084643c",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "Whenever we are using comparison operators(==,!=) for List objects then the following should be considered\n",
    "\n",
    " 1. The number of elements\n",
    " 2. The order of elements\n",
    " 3. The content of elements (case sensitive)\n",
    "\n",
    "#### Note: \n",
    "When ever we are using relatational operators(<,<=,>,>=) between List objects,only first element comparison will be performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1d70a4e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x=[50,20,30] \n",
    "y=[40,50,60,100,200] \n",
    "print(x>y) \n",
    "print(x>=y) \n",
    "print(x<y) \n",
    "print(x<=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "d15ce3fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x=[\"Dog\",\"Cat\",\"Rat\"] \n",
    "y=[\"Rat\",\"Cat\",\"Dog\"] \n",
    "print(x>y)  \n",
    "print(x>=y)  \n",
    "print(x<y)  \n",
    "print(x<=y) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432ba080",
   "metadata": {},
   "source": [
    "## Membership operators:\n",
    "We can check whether element is a member of the list or not by using memebership operators.\n",
    "- in operator\n",
    "- not in operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "81b0b3ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[10,20,30,40] \n",
    "print (10 in n) \n",
    "print (10 not in n) \n",
    "print (50 in n) \n",
    "print (50 not in n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54a10b90",
   "metadata": {},
   "source": [
    "### clear() function:\n",
    "We can use clear() function to remove all elements of List.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "7c2b0742",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[10,20,30,40] \n",
    "print(n) \n",
    "n.clear() \n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f3d5fbd",
   "metadata": {},
   "source": [
    "### Nested Lists:\n",
    "Sometimes we can take one list inside another list. Such type of lists are called nested lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "3b50d866",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, [30, 40]]\n",
      "10\n",
      "[30, 40]\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "n=[10,20,[30,40]] \n",
    "print(n) \n",
    "print(n[0]) \n",
    "print(n[2]) \n",
    "print(n[2][0]) \n",
    "print(n[2][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46383bad",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "We can access nested list elements by using index just like accessing multi \n",
    "dimensional array elements.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7fd6546",
   "metadata": {},
   "source": [
    "### Nested List as Matrix:\n",
    "In Python we can represent matrix by using nested lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "568782bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10, 20, 30], [40, 50, 60], [70, 80, 90]]\n",
      "Elements by Row wise:\n",
      "[10, 20, 30]\n",
      "[40, 50, 60]\n",
      "[70, 80, 90]\n",
      "Elements by Matrix style:\n",
      "10 20 30 \n",
      "40 50 60 \n",
      "70 80 90 \n"
     ]
    }
   ],
   "source": [
    "n=[[10,20,30],[40,50,60],[70,80,90]] \n",
    "print(n) \n",
    "print(\"Elements by Row wise:\") \n",
    "for r in n: \n",
    "    print(r) \n",
    "print(\"Elements by Matrix style:\") \n",
    "for i in range(len(n)): \n",
    "    for j in range(len(n[i])): \n",
    "        print(n[i][j],end=' ') \n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4c632a",
   "metadata": {},
   "source": [
    "## List Comprehensions:\n",
    "It is very easy and compact way of creating list objects from any iterable objects(like list,tuple,dictionary,range etc) based on some condition.\n",
    "\n",
    "    Syntax:\n",
    "    new_list = [expression for_loop_one_or_more conditions]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "237eaa18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "[2, 4, 8, 16, 32]\n",
      "[4, 16, 36, 64, 100]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s=[ x*x for x in range(1,11)] \n",
    "print(s) \n",
    "v=[2**x for x in range(1,6)] \n",
    "print(v) \n",
    "m=[x for x in s if x%2==0] \n",
    "print(m) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "3b42caf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# Finding squares of numbers in a list with the help of list comprehensions:\n",
    "numbers = [1, 2, 3, 4]\n",
    "squares = [n**2 for n in numbers]\n",
    "print(squares) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "3171c369",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B', 'N', 'V', 'C']\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "words=[\"Balaiah\",\"Nag\",\"Venkatesh\",\"Chiranjeevi\"] \n",
    "l=[w[0] for w in words] \n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "a3d7b766",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Find common numbers from two lists using list comprehension:\n",
    "list_a = [1, 2, 3, 4]\n",
    "list_b = [2, 3, 4, 5]\n",
    "common_num = [a for a in list_a for b in list_b if a == b]\n",
    "print(common_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "6106a98b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20]\n",
      "[30, 40]\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "num1=[10,20,30,40] \n",
    "num2=[30,40,50,60] \n",
    "num3=[ i for i in num1 if i not in num2] \n",
    "print(num3) \n",
    "\n",
    "# common elements present in num1 and num2 \n",
    "num4=[i for i in num1 if i in num2] \n",
    "print(num4) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "570d0bda",
   "metadata": {},
   "source": [
    "### All List Methods\n",
    "\n",
    "        Method ----> Description\n",
    "        \n",
    "    append() ----> Adds an element at the end of the list\n",
    "    clear() ----> Removes all the elements from the list\n",
    "    copy() ----> Returns a copy of the list\n",
    "    count() ----> Returns the number of elements with the specified value\n",
    "    extend() ----> Add the elements of a list (or any iterable), to the end of the current list\n",
    "    index() ----> Returns the index of the first element with the specified value\n",
    "    insert() ----> Adds an element at the specified position\n",
    "    pop() ----> Removes the element at the specified position\n",
    "    remove() ----> Removes the first item with the specified value\n",
    "    reverse() ----> Reverses the order of the list\n",
    "    sort() ----> Sorts the list\n",
    "    sum() ----> Return sum of all elements in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5354d3b9",
   "metadata": {},
   "source": [
    "## Dictionary Data Structure\n",
    "We can use List,Tuple and Set to represent a group of individual objects as a single entity.\n",
    "\n",
    "\n",
    "If we want to represent a group of objects as key-value pairs then we should go for Dictionary.\n",
    "     \n",
    "     Eg:\n",
    "     rollno ---- name\n",
    "     phone number -- address\n",
    "     ipaddress --- domain name\n",
    "     \n",
    "- Duplicate keys are not allowed but values can be duplicated.\n",
    "- Hetrogeneous objects are allowed for both key and values.\n",
    "- insertion order is not preserved\n",
    "- Dictionaries are mutable\n",
    "- Dictionaries are dynamic\n",
    "- indexing and slicing concepts are not applicable\n",
    "\n",
    "#### Note: \n",
    "In C++ and Java Dictionaries are known as \"Map\" where as in Perl and Ruby it is known as \"Hash\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14be2462",
   "metadata": {},
   "source": [
    "### How to create Dictionary?\n",
    "\n",
    "    d={} or d=dict()\n",
    "we are creating empty dictionary. We can add entries as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "b6471df1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100: 'nikhil', 200: 'prakriti', 300: 'delhi'}\n"
     ]
    }
   ],
   "source": [
    "d={}\n",
    "d[100]=\"nikhil\"\n",
    "d[200]=\"prakriti\"\n",
    "d[300]=\"delhi\"\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b14e7870",
   "metadata": {},
   "source": [
    "If we know data in advance then we can create dictionary as follows\n",
    "\n",
    "    d={key:value, key:value}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "c5b1eb3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "months= {1:\"January\", 2:\"February\", 3: \"March\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d3cf177",
   "metadata": {},
   "source": [
    "### How to access data from the dictionary?\n",
    "We can access data by using keys.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "8f04a16f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhil\n",
      "delhi\n"
     ]
    }
   ],
   "source": [
    "d={100:'nikhil' ,200:'prakriti', 300:'delhi'}\n",
    "print(d[100]) \n",
    "print(d[300])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a285f70",
   "metadata": {},
   "source": [
    "If the specified key is not available then we will get KeyError\n",
    "    \n",
    "    print(d[400]) # KeyError: 400\n",
    "    \n",
    "#### Q. Write a program to enter name and percentage marks in a dictionary and display information on the screen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "9ca25259",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of students: 2\n",
      "Enter Student Name: Nikhil Yadav\n",
      "Enter % of Marks of Student: 95\n",
      "Enter Student Name: Prakriti Yadav\n",
      "Enter % of Marks of Student: 99\n",
      "Name of Student \t % of marks\n",
      "\t Nikhil Yadav \t\t 95\n",
      "\t Prakriti Yadav \t\t 99\n"
     ]
    }
   ],
   "source": [
    "rec={} \n",
    "n=int(input(\"Enter number of students: \")) \n",
    "i=1 \n",
    "while i <=n: \n",
    "    name=input(\"Enter Student Name: \") \n",
    "    marks=input(\"Enter % of Marks of Student: \") \n",
    "    rec[name]=marks \n",
    "    i=i+1 \n",
    "print(\"Name of Student\",\"\\t\",\"% of marks\") \n",
    "for x in rec: \n",
    "    print(\"\\t\",x,\"\\t\\t\",rec[x])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ffbadd7",
   "metadata": {},
   "source": [
    "### How to update dictionaries?\n",
    "\n",
    "    d[key]=value\n",
    "If the key is not available then a new entry will be added to the dictionary with the specified key-value pair\n",
    "\n",
    "If the key is already available then old value will be replaced with new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "afb5f5cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100: 'Happy', 200: 'Prakriti', 300: 'Delhi'}\n",
      "{100: 'Happy', 200: 'Prakriti', 300: 'Delhi', 400: 'Akhil'}\n",
      "{100: 'Nikhil', 200: 'Prakriti', 300: 'Delhi', 400: 'Akhil'}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"Happy\",200:\"Prakriti\",300:\"Delhi\"} \n",
    "print(d) \n",
    "d[400]=\"Akhil\" \n",
    "print(d) \n",
    "d[100]=\"Nikhil\" \n",
    "print(d) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466e79c9",
   "metadata": {},
   "source": [
    "### How to delete elements from dictionary?\n",
    "\n",
    "    del d[key]\n",
    "- It deletes entry associated with the specified key.\n",
    "- If the key is not available then we will get KeyError\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "9625de9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100: 'nikhil', 200: 'prakriti', 300: 'yadav'}\n",
      "{200: 'prakriti', 300: 'yadav'}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d) \n",
    "del d[100] \n",
    "print(d) \n",
    "#del d[400] --> KeyError: 400"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34e9f193",
   "metadata": {},
   "source": [
    "### d.clear()\n",
    "To remove all entries from the dictionary\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "0a782f45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100: 'nikhil', 200: 'prakriti', 300: 'yadav'}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d) \n",
    "d.clear() \n",
    "print(d) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b545f2a",
   "metadata": {},
   "source": [
    "### del d\n",
    "To delete total dictionary.Now we cannot access d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "e779c1e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100: 'nikhil', 200: 'prakriti', 300: 'yadav'}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d) \n",
    "del d \n",
    "#print(d) ---> NameError: name 'd' is not defined "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a44f387d",
   "metadata": {},
   "source": [
    "## Important functions of dictionary:\n",
    "### 1. dict():\n",
    "\n",
    "To create a dictionary\n",
    "\n",
    "    d=dict() ===> It creates empty dictionary\n",
    "    d=dict({100:\"durga\",200:\"ravi\"}) ==> It creates dictionary with specified elements\n",
    "    d=dict([(100,\"durga\"),(200,\"shiva\"),(300,\"ravi\")])==>It creates dictionary with the given list of tuple elements\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf75a5c0",
   "metadata": {},
   "source": [
    "### 2. len()\n",
    "Returns the number of items in the dictionary\n",
    "### 3. clear():\n",
    "To remove all elements from the dictionary\n",
    "### 4. get():\n",
    "To get the value associated with the key\n",
    "\n",
    "    d.get(key) \n",
    "     If the key is available then returns the corresponding value otherwise returns None.It wont raise any error.\n",
    "\n",
    "    d.get(key,defaultvalue)\n",
    "    If the key is available then returns the corresponding value otherwise returns default value.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "a733bc95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhil\n",
      "nikhil\n",
      "None\n",
      "nikhil\n",
      "Guest\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d[100]) \n",
    "#print(d[400]) ==>KeyError:400 \n",
    "print(d.get(100)) \n",
    "print(d.get(400)) \n",
    "print(d.get(100,\"Guest\")) \n",
    "print(d.get(400,\"Guest\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f968f05b",
   "metadata": {},
   "source": [
    "### 3. pop():\n",
    "\n",
    "    d.pop(key)\n",
    " It removes the entry associated with the specified key and returns the corresponding \n",
    "\n",
    "    value\n",
    "     \n",
    "If the specified key is not available then we will get KeyError\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "5d547ef4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nikhil\n",
      "{200: 'prakriti', 300: 'yadav'}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d.pop(100)) \n",
    "print(d) \n",
    "#print(d.pop(400)) --->  KeyError: 400 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fb2de03",
   "metadata": {},
   "source": [
    "### 4. popitem():\n",
    "It removes an arbitrary item(key-value) from the dictionaty and returns it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ab85aa4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{100: 'nikhil', 200: 'prakriti', 300: 'yadav'}\n",
      "(300, 'yadav')\n",
      "{100: 'nikhil', 200: 'prakriti'}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d) \n",
    "print(d.popitem()) \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83a08072",
   "metadata": {},
   "source": [
    "If the dictionary is empty then we will get KeyError\n",
    "    \n",
    "    d={}\n",
    "    print(d.popitem()) ==>KeyError: 'popitem(): dictionary is empty'\n",
    "### 5. keys():\n",
    "It returns all keys associated eith dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "e521b4e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys([100, 200, 300])\n",
      "100\n",
      "200\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d.keys()) \n",
    "for k in d.keys(): \n",
    "    print(k) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1cc2cd5",
   "metadata": {},
   "source": [
    "### 6. values():\n",
    "It returns all values associated with the dictionary\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "004788ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['nikhil', 'prakriti', 'yadav'])\n",
      "nikhil\n",
      "prakriti\n",
      "yadav\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "print(d.values()) \n",
    "for v in d.values(): \n",
    "    print(v) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33b78ee7",
   "metadata": {},
   "source": [
    "### 7. items():\n",
    "It returns list of tuples representing key-value pairs.\n",
    "\n",
    "    [(k,v),(k,v),(k,v)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "dfab7dbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 -- nikhil\n",
      "200 -- prakriti\n",
      "300 -- yadav\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"yadav\"} \n",
    "for k,v in d.items(): \n",
    "    print(k,\"--\",v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27dbc401",
   "metadata": {},
   "source": [
    "### 8. copy():\n",
    "To create exactly duplicate dictionary(cloned copy)\n",
    "\n",
    "    d1=d.copy();\n",
    "### 9. setdefault():\n",
    "\n",
    "    d.setdefault(k,v)\n",
    "- If the key is already available then this function returns the corresponding value.\n",
    "- If the key is not available then the specified key-value will be added as new item to the dictionary.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "7de05eed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "happy\n",
      "{100: 'nikhil', 200: 'prakriti', 300: 'chunmun', 400: 'happy'}\n",
      "nikhil\n",
      "{100: 'nikhil', 200: 'prakriti', 300: 'chunmun', 400: 'happy'}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "d={100:\"nikhil\",200:\"prakriti\",300:\"chunmun\"} \n",
    "print(d.setdefault(400,\"happy\")) \n",
    "print(d) \n",
    "print(d.setdefault(100,\"akhil\")) \n",
    "print(d) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "814256da",
   "metadata": {},
   "source": [
    "### 10. update():\n",
    "    \n",
    "    d.update(x)\n",
    "All items present in the dictionary x will be added to dictionary d\n",
    "#### Q. Write a program to find number of occurrences of each letter present in the given string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "9b5196b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any word: n\n",
      "n occurred  1  times\n"
     ]
    }
   ],
   "source": [
    "word=input(\"Enter any word: \") \n",
    "d={} \n",
    "for x in word: \n",
    "    d[x]=d.get(x,0)+1 \n",
    "for k,v in d.items(): \n",
    "    print(k,\"occurred \",v,\" times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c446e588",
   "metadata": {},
   "source": [
    "### Dictionary Comprehension:\n",
    "Comprehension concept applicable for dictionaries also.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "48814239",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
      "{1: 2, 2: 4, 3: 6, 4: 8, 5: 10}\n"
     ]
    }
   ],
   "source": [
    "squares={x:x*x for x in range(1,6)} \n",
    "print(squares) \n",
    "doubles={x:2*x for x in range(1,6)} \n",
    "print(doubles) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66ae7969",
   "metadata": {},
   "source": [
    "### Iterating over a Dictionary:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "8a1c3e68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "bar= {2:1,3:2,4:3}\n",
    "for t in bar:\n",
    "    print(t)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7e2ace2",
   "metadata": {},
   "source": [
    "### All Dictionary Methods\n",
    "\n",
    "    Method ----> Description\n",
    "\n",
    "    clear() ----> Removes all the elements from the dictionary\n",
    "    copy() ----> Returns a copy of the dictionary\n",
    "    fromkeys() ----> Returns a dictionary with the specified keys and value\n",
    "    get() ----> Returns the value of the specified key\n",
    "    items() ----> Returns a list containing a tuple for each key value pair\n",
    "    keys() ----> Returns a list containing the dictionary's keys\n",
    "    pop() ----> Removes the element with the specified key\n",
    "    popitem() ----> Removes the last inserted key-value pair\n",
    "    setdefault() ----> Returns the value of the specified key. If the key does not exist: insert the key, with the specified value\n",
    "    update() ----> Updates the dictionary with the specified key-value pairs\n",
    "    values() ----> Returns a list of all the values in the dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a9aacec",
   "metadata": {},
   "source": [
    "## Tuple Data Structure\n",
    "1. Tuple is exactly same as List except that it is immutable. i.e once we creates Tuple \n",
    "\n",
    "object,we cannot perform any changes in that object.\n",
    "Hence Tuple is Read Only version of List.\n",
    "\n",
    "2. If our data is fixed and never changes then we should go for Tuple.\n",
    "3. Insertion Order is preserved\n",
    "4. Duplicates are allowed\n",
    "5. Heterogeneous objects are allowed.\n",
    "6. We can preserve insertion order and we can differentiate duplicate objects by using index. Hence index will play very important role in Tuple also.\n",
    "\n",
    "Tuple support both +ve and -ve index. +ve index means forward direction(from left to right) and -ve index means backward direction(from right to left)\n",
    "\n",
    "7. We can represent Tuple elements within Parenthesis and with comma seperator.\n",
    "\n",
    "Parenethesis are optional but recommended to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "1a101ffe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30, 40)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "t=10,20,30,40 \n",
    "print(t) \n",
    "print(type(t)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6d0313a",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "We have to take special care about single valued tuple.compulsary the value \n",
    "should ends with comma,otherwise it is not treated as tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "a33c9c6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "t=(10) \n",
    "print(t) \n",
    "print(type(t)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3fcd0847",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "t=(10,) \n",
    "print(t) \n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6979205",
   "metadata": {},
   "source": [
    "### Tuple creation:\n",
    "#### 1. t=()\n",
    " creation of empty tuple\n",
    "#### 2. t=(10,)\n",
    " \n",
    "     t=10,\n",
    "\n",
    "creation of single valued tuple ,parenthesis are optional,should ends with comma\n",
    "#### 3. t=10,20,30\n",
    " \n",
    "     t=(10,20,30)\n",
    "\n",
    "creation of multi values tuples & parenthesis are optional\n",
    "#### 4. By using tuple() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "ca674b16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30)\n",
      "(10, 12, 14, 16, 18)\n"
     ]
    }
   ],
   "source": [
    "list=[10,20,30] \n",
    "t=tuple(list) \n",
    "print(t) \n",
    "\n",
    "t=tuple(range(10,20,2)) \n",
    "print(t) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c165425",
   "metadata": {},
   "source": [
    "### Accessing elements of tuple:\n",
    "We can access either by index or by slice operator\n",
    "#### 1. By using index:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "42ce6a31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "t=(10,20,30,40,50,60) \n",
    "print(t[0])  \n",
    "print(t[-1])  \n",
    "# print(t[100]) IndexError: tuple index out of range"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dda850b",
   "metadata": {},
   "source": [
    "#### By using slice operator:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "4c0163f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(30, 40, 50)\n",
      "(30, 40, 50, 60)\n",
      "(10, 30, 50)\n"
     ]
    }
   ],
   "source": [
    "t=(10,20,30,40,50,60) \n",
    "print(t[2:5]) \n",
    "print(t[2:100]) \n",
    "print(t[::2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abbafdcf",
   "metadata": {},
   "source": [
    "### Tuple vs immutability:\n",
    "Once we creates tuple,we cannot change its content.\n",
    "\n",
    "Hence tuple objects are immutable.\n",
    " \n",
    "    Eg:\n",
    "    t=(10,20,30,40)\n",
    "    t[1]=70 TypeError: 'tuple' object does not support item assignment\n",
    "## Mathematical operators for tuple:\n",
    "\n",
    "We can apply + and * operators for tuple\n",
    "#### 1. Concatenation Operator(+):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "2d64c7e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30, 40, 50, 60)\n"
     ]
    }
   ],
   "source": [
    "t1=(10,20,30) \n",
    "t2=(40,50,60) \n",
    "t3=t1+t2 \n",
    "print(t3) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed9aa94",
   "metadata": {},
   "source": [
    "#### 2. Multiplication operator or repetition operator(*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "2448310a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30, 10, 20, 30, 10, 20, 30)\n"
     ]
    }
   ],
   "source": [
    "t1=(10,20,30) \n",
    "t2=t1*3 \n",
    "print(t2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f04953af",
   "metadata": {},
   "source": [
    "### Important functions of Tuple:\n",
    "#### 1. len()\n",
    " To return number of elements present in the tuple\n",
    " \n",
    "     Eg:\n",
    "     t=(10,20,30,40)\n",
    "     print(len(t)) #4\n",
    "     \n",
    "#### 2. count()\n",
    " To return number of occurrences of given element in the tuple\n",
    "     \n",
    "     Eg:\n",
    "     t=(10,20,10,10,20)\n",
    "     print(t.count(10)) #3\n",
    "     \n",
    "#### 3. index()\n",
    " returns index of first occurrence of the given element.\n",
    " If the specified element is not available then we will get ValueError.\n",
    " \n",
    "        Eg:\n",
    "        t=(10,20,10,10,20)\n",
    "        print(t.index(10)) #0\n",
    "        print(t.index(30)) ValueError: tuple.index(x): x not in tuple\n",
    "#### 4. sorted()\n",
    " To sort elements based on default natural sorting order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "b68099f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n",
      "(40, 10, 30, 20)\n"
     ]
    }
   ],
   "source": [
    "t=(40,10,30,20) \n",
    "t1=sorted(t) \n",
    "print(t1) \n",
    "print(t) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4da688eb",
   "metadata": {},
   "source": [
    "We can sort according to reverse of default natural sorting order as follows\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "b23ab719",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 30, 20, 10]\n"
     ]
    }
   ],
   "source": [
    "t1=sorted(t,reverse=True)\n",
    "print(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d96c6ee0",
   "metadata": {},
   "source": [
    "### 5. min() and max() functions:\n",
    "These functions return min and max values according to default natural sorting order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "08c324e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "t=(40,10,30,20) \n",
    "print(min(t))  \n",
    "print(max(t))  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec8dac81",
   "metadata": {},
   "source": [
    "### Tuple Packing and Unpacking:\n",
    "We can create a tuple by packing a group of variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "018feab0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30, 40)\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "a=10\n",
    "b=20\n",
    "c=30\n",
    "d=40\n",
    "t=a,b,c,d\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39513a0b",
   "metadata": {},
   "source": [
    "Here a,b,c,d are packed into a tuple t. This is nothing but tuple packing.\n",
    "\n",
    "Tuple unpacking is the reverse process of tuple packing\n",
    "\n",
    "We can unpack a tuple and assign its values to different variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "c5cc080d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a= 10 b= 20 c= 30 d= 40\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "t=(10,20,30,40) \n",
    "a,b,c,d=t \n",
    "print(\"a=\",a,\"b=\",b,\"c=\",c,\"d=\",d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "113b4f34",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "At the time of tuple unpacking the number of variables and number of values \n",
    "should be same. ,otherwise we will get ValueError.\n",
    "\n",
    "    Eg:\n",
    "    t=(10,20,30,40)\n",
    "    a,b,c=t #ValueError: too many values to unpack (expected 3)\n",
    "### Tuple Comprehension:\n",
    "Tuple Comprehension is not supported by Python.\n",
    " \n",
    "     t= ( x**2 for x in range(1,6))\n",
    "\n",
    "Here we are not getting tuple object and we are getting generator object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "aac67b0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "t= ( x**2 for x in range(1,6)) \n",
    "print(type(t)) \n",
    "for x in t: \n",
    "    print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28c3e5a3",
   "metadata": {},
   "source": [
    "#### Q. Write a program to take a tuple of numbers from the keyboard and print its sum and average?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "9837bb19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Tuple of Numbers:12,1,3,2,34,2\n",
      "The Sum= 54\n",
      "The Average= 9.0\n"
     ]
    }
   ],
   "source": [
    "t=eval(input(\"Enter Tuple of Numbers:\")) \n",
    "l=len(t) \n",
    "sum=0 \n",
    "for x in t: \n",
    "    sum=sum+x \n",
    "print(\"The Sum=\",sum) \n",
    "print(\"The Average=\",sum/l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f62ec30",
   "metadata": {},
   "source": [
    "## Differences between List and Tuple:\n",
    "List and Tuple are exactly same except small difference: List objects are mutable where as Tuple objects are immutable.\n",
    "\n",
    "In both cases insertion order is preserved, duplicate objects are allowed, heterogenous objects are allowed, index and slicing are supported. \n",
    "\n",
    "### List \n",
    "1) List is a Group of Comma separeated Values within Square Brackets and Square Brackets are mandatory.\n",
    "\n",
    "    Eg: i = [10, 20, 30, 40]\n",
    "    \n",
    "2) List Objects are Mutable i.e. once we creates List Object we can perform any changes in that Object.\n",
    "\n",
    "    Eg: i[1] = 70\n",
    "\n",
    "3) If the Content is not fixed and keep on changing then we should go for List.\n",
    "\n",
    "4) List Objects can not used as Keys for Dictionries because Keys should be Hashable and Immutable.\n",
    "\n",
    "### Tuple\n",
    "1) Tuple is a Group of Comma separeated Values within Parenthesis and Parenthesis are optional.\n",
    "\n",
    "    Eg: t = (10, 20, 30, 40)\n",
    "     \n",
    "     t = 10, 20, 30, 40\n",
    "\n",
    "2) Tuple Objeccts are Immutable i.e. once we creates Tuple Object we cannot change its content.\n",
    "\n",
    "    t[1] = 70  ValueError: tuple object does not support item assignment.\n",
    "\n",
    "3) If the content is fixed and never changes then we should go for Tuple\n",
    "\n",
    "4) Tuple Objects can be used as Keys for Dictionries because Keys should be Hashable and Immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a709790",
   "metadata": {},
   "source": [
    "### All Tuple Methods\n",
    "\n",
    "    Method ----> Description\n",
    "\n",
    "    count(x) ----> Returns the number of times a specified value occurs in a tuple\n",
    "    index(x) ----> Searches the tuple for a specified value and returns the position of where it was found\n",
    "    sorted(tpl) ----> Sorts the elements of tuple into ascending order.\n",
    "    min(tpl) ----> Return the smallest element in the tuple.\n",
    "    max(tpl) ----> Return the biggest element in the tuple.\n",
    "    len(tpl) ----> Return the number of elements in the tuple.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bfe4c9f",
   "metadata": {},
   "source": [
    "## Set Data Structure\n",
    " \n",
    "- If we want to represent a group of unique values as a single entity then we should go for set.\n",
    "- Duplicates are not allowed.\n",
    "- Insertion order is not preserved.But we can sort the elements.\n",
    "- Indexing and slicing not allowed for the set.\n",
    "- Heterogeneous elements are allowed.\n",
    "- Set objects are mutable i.e once we creates set object we can perform any changes in that object based on our requirement.\n",
    "- We can represent set elements within curly braces and with comma seperation\n",
    "- We can apply mathematical operations like union,intersection,difference etc on set objects. Creation of Set objects:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72d13765",
   "metadata": {},
   "source": [
    "### Creation of Set objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "99c8db76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 20, 30}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s={10,20,30,40} \n",
    "print(s) \n",
    "print(type(s)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03ec5e19",
   "metadata": {},
   "source": [
    "We can create set objects by using set() function\n",
    "\n",
    "    s=set(any sequence)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "bbb85c20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 20, 30}\n"
     ]
    }
   ],
   "source": [
    "# Eg 1:\n",
    "l = [10,20,30,40,10,20,10] \n",
    "s=set(l) \n",
    "print(s)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "edba0f3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "# Eg 2:\n",
    "s=set(range(5)) \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99216794",
   "metadata": {},
   "source": [
    "#### Note: \n",
    "While creating empty set we have to take special care.\n",
    "Compulsory we should use set() function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dc0139d",
   "metadata": {},
   "source": [
    "    s={} ==>It is treated as dictionary but not empty set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "e4155cb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s={} \n",
    "print(s) \n",
    "print(type(s)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "479ee035",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s=set() \n",
    "print(s) \n",
    "print(type(s)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24d14475",
   "metadata": {},
   "source": [
    "## Important functions of set:\n",
    "### 1. add(x):\n",
    "Adds item x to the set\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "1004bdb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 20, 30}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s={10,20,30} \n",
    "s.add(40); \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75cfb5a6",
   "metadata": {},
   "source": [
    "### 2. update(x,y,z):\n",
    "- To add multiple items to the set.\n",
    "- Arguments are not individual elements and these are Iterable objects like List,range etc.\n",
    "- All elements present in the given Iterable objects will be added to the set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "8df6261a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 40, 10, 50, 20, 60, 30}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s={10,20,30} \n",
    "l=[40,50,60,10] \n",
    "s.update(l,range(5)) \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39c9f11b",
   "metadata": {},
   "source": [
    "#### Q. What is the difference between add() and update() functions in set?\n",
    "We can use add() to add individual item to the Set,where as we can use update() function \n",
    "to add multiple items to Set.\n",
    "\n",
    "add() function can take only one argument where as update() function can take any \n",
    "number of arguments but all arguments should be iterable objects.\n",
    "#### Q. Which of the following are valid for set s?\n",
    "1. s.add(10)\n",
    "2. s.add(10,20,30) TypeError: add() takes exactly one argument (3 given)\n",
    "3. s.update(10) TypeError: 'int' object is not iterable\n",
    "4. s.update(range(1,10,2),range(0,10,2))\n",
    "\n",
    "### 3. copy():\n",
    "\n",
    "    Returns copy of the set.\n",
    "    It is cloned object.\n",
    "    s={10,20,30}\n",
    "    s1=s.copy()\n",
    "    print(s1)\n",
    "\n",
    "### 4. pop():\n",
    "It removes and returns some random element from the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "f0a37c77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 20, 30}\n",
      "40\n",
      "{10, 20, 30}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "s={40,10,30,20} \n",
    "print(s) \n",
    "print(s.pop()) \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7fafd41",
   "metadata": {},
   "source": [
    "### 5. remove(x):\n",
    "It removes specified element from the set.\n",
    "\n",
    "If the specified element not present in the Set then we will get KeyError\n",
    "\n",
    "    s={40,10,30,20}\n",
    "    s.remove(30)\n",
    "    print(s) # {40, 10, 20} \n",
    "    s.remove(50) ==>KeyError: 50\n",
    "\n",
    "### 6. discard(x):\n",
    "It removes the specified element from the set.\n",
    "\n",
    "If the specified element not present in the set then we won't get any error.\n",
    "    \n",
    "    s={10,20,30}\n",
    "    s.discard(10)\n",
    "    print(s) ===>{20, 30}\n",
    "    s.discard(50)\n",
    "    print(s) ==>{20, 30}\n",
    "    \n",
    "#### Q. What is the difference between remove() and discard() functions in Set?\n",
    "#### Q. Explain differences between pop(),remove() and discard() functionsin Set?\n",
    "### 7.clear():\n",
    "To remove all elements from the Set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "d9c7a64f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 20, 30}\n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "s={10,20,30} \n",
    "print(s) \n",
    "s.clear() \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "495fbb78",
   "metadata": {},
   "source": [
    "## Mathematical operations on the Set:\n",
    "    \n",
    "### 1.union():\n",
    "    \n",
    "    x.union(y) ==>We can use this function to return all elements present in both sets\n",
    "    x.union(y) or x|y\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "377d14e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 50, 20, 60, 30}\n",
      "{40, 10, 50, 20, 60, 30}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x={10,20,30,40}\n",
    "y={30,40,50,60}\n",
    "print(x.union(y)) \n",
    "print(x|y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "190045fb",
   "metadata": {},
   "source": [
    "### 2. intersection():\n",
    "    x.intersection(y) or x&y\n",
    "    Returns common elements present in both x and y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "7c930d8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 30}\n",
      "{40, 30}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x={10,20,30,40}\n",
    "y={30,40,50,60}\n",
    "print(x.intersection(y))\n",
    "print(x&y) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "400ffc98",
   "metadata": {},
   "source": [
    "### 3. difference():\n",
    "    x.difference(y) or x-y\n",
    "    returns the elements present in x but not in y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "23739b45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 20}\n",
      "{10, 20}\n",
      "{50, 60}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x={10,20,30,40}\n",
    "y={30,40,50,60}\n",
    "print(x.difference(y))\n",
    "print(x-y) \n",
    "print(y-x) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f965febd",
   "metadata": {},
   "source": [
    "### 4.symmetric_difference():\n",
    "    x.symmetric_difference(y) or x^y\n",
    "    Returns elements present in either x or y but not in both\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "f8a27677",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 50, 20, 60}\n",
      "{10, 50, 20, 60}\n"
     ]
    }
   ],
   "source": [
    "# Eg:\n",
    "x={10,20,30,40}\n",
    "y={30,40,50,60}\n",
    "print(x.symmetric_difference(y))\n",
    "print(x^y) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5ca3f5a",
   "metadata": {},
   "source": [
    "## Membership operators: (in , not in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "c4ca8ccb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'r', 'd', 'g', 'a', 'u'}\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s=set(\"durga\") \n",
    "print(s) \n",
    "print('d' in s) \n",
    "print('z' in s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1efa6236",
   "metadata": {},
   "source": [
    "## Set Comprehension:\n",
    "Set comprehension is possible.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "be1210ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 4, 9, 16}\n",
      "{16, 256, 64, 4}\n"
     ]
    }
   ],
   "source": [
    "s={x*x for x in range(5)}\n",
    "print(s) #{0, 1, 4, 9, 16}\n",
    "s={2**x for x in range(2,10,2)}\n",
    "print(s) #{16, 256, 64, 4}\n",
    "# set objects won't support indexing and slicing:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a03eee7c",
   "metadata": {},
   "source": [
    "    Eg:\n",
    "    s={10,20,30,40}\n",
    "    print(s[0]) ==>TypeError: 'set' object does not support indexing\n",
    "    print(s[1:3]) ==>TypeError: 'set' object is not subscriptable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8bfaeab",
   "metadata": {},
   "source": [
    "### Q.Write a program to eliminate duplicates present in the list?\n",
    "#### Approach-1:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "53605059",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter List of values: 2,3,4,2\n",
      "{2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "l=eval(input(\"Enter List of values: \")) \n",
    "s=set(l) \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86d85ad",
   "metadata": {},
   "source": [
    "#### Approach-2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "905a6829",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter List of values: 12,3,4,2,4,2\n",
      "[12]\n",
      "[12, 3]\n",
      "[12, 3, 4]\n",
      "[12, 3, 4, 2]\n",
      "[12, 3, 4, 2]\n",
      "[12, 3, 4, 2]\n"
     ]
    }
   ],
   "source": [
    "l=eval(input(\"Enter List of values: \")) \n",
    "l1=[] \n",
    "for x in l: \n",
    "    if x not in l1: \n",
    "        l1.append(x) \n",
    "    print(l1) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e189cc1e",
   "metadata": {},
   "source": [
    "### All Set Methods\n",
    "\n",
    "    Method ----> Description\n",
    "    add() ----> Adds an element to the set\n",
    "    clear() ----> Removes all the elements from the set\n",
    "    copy() ----> Returns a copy of the set\n",
    "    difference() ----> Returns a set containing the difference between two or more sets\n",
    "    difference_update() ----> Removes the items in this set that are also included in another, specified set\n",
    "    discard() ----> Remove the specified item\n",
    "    intersection() ----> Returns a set, that is the intersection of two or more sets\n",
    "    intersection_update() ----> Removes the items in this set that are not present in other, specified set(s)\n",
    "    isdisjoint() ----> Returns whether two sets have a intersection or not\n",
    "    issubset() ----> Returns whether another set contains this set or not\n",
    "    issuperset() ----> Returns whether this set contains another set or not\n",
    "    pop() ----> Removes an element from the set\n",
    "    remove() ----> Removes the specified element\n",
    "    symmetric_difference() ----> Returns a set with the symmetric differences of two sets\n",
    "    symmetric_difference_update() ----> inserts the symmetric differences from this set and another\n",
    "    union() ----> Return a set containing the union of sets\n",
    "    update() ----> Update the set with another set, or any other iterable"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}