09 Set Class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>09 Set</h2> \n",
    "<h3>\n",
    "> If we want to represent a group of unique values as a single entity then we should go\n",
    "for set.\n",
    "<br/>> Duplicates are not allowed.\n",
    "<br/>> Insertion order is not preserved.But we can sort the elements.\n",
    "<br/>> Indexing and slicing not allowed for the set.\n",
    "<br/>> Heterogeneous elements are allowed.\n",
    "<br/>> Set objects are partially changeable as we can add or remove elements but cannot change existing elments using index notation ex. set[index]=new_value cannot be done\n",
    "<br/>> We can represent set elements within curly braces and with comma seperation\n",
    "<br/>> We can apply mathematical operations like union,intersection,difference etc on set\n",
    "objects.\n",
    "<br/>> A set is a collection which is unordered, unindexed and no-duplicates.\n",
    "</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating Set objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{} <class 'dict'>\n",
      "set() <class 'set'>\n",
      "{'C', 'B', 40, 10, 20, 'A', 30} <class 'set'>\n",
      "{10, 20, 30} <class 'set'>\n",
      "{1, 2, 3, 'B', 'C', 'A'} <class 'set'>\n",
      "[10, 20, 50, 80]\n",
      "{40, 10, 20, 30} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "s1={} # this will create an empty dictionary object not set object\n",
    "print(s1,type(s1))\n",
    "s2=set() # this will create an empty set object\n",
    "print(s2,type(s2))\n",
    "s3={10,20,30,40,'A','B','C'} # Heterogenous Set\n",
    "print(s3,type(s3))\n",
    "s4={10,10,20,20,30,30}\n",
    "print(s4,type(s4)) #Duplicates are not allowed, so {10, 20, 30}\n",
    "s5={1,2,3,'A','B','C'} #Insertion order is not preserved\n",
    "print(s5,type(s5))\n",
    "s6={50,20,80,10}\n",
    "print(sorted(s6)) #sorting can be done only on homegeneous set\n",
    "# print(s6[0]) # Indexing and slicing not allowed as Set is not subscritpable\n",
    "# print(s6[::]) # Indexing and slicing not allowed as Set is not subscritpable\n",
    "l1=[10,20,30,40] # list\n",
    "s7=set(l1) #converting a list to set\n",
    "print(s7,type(s7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some important Set class Member Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## > set.add(object): Adds one object at a time in the set. Accepts only one argument.\n",
    "## >  set.update(iterable): updates the current set, by adding items from another set (or any other iterable). We can use any number of iterables in the input argument.\n",
    "## >  set.pop(): Removes a random item from the set. This method returns the removed item.\n",
    "## >  set.discard(value): It removes the specified item from the set. This method is different from the remove() method, because the remove() method will raise an error if the specified item does not exist, and the discard() method will not.\n",
    "## >  set.remove(item): Removes the specified element from the set.This method is different from the discard() method, because the remove() method will raise an error if the specified item does not exist, and the discard() method will not.\n",
    "## >  set.clear(): Removes all the elements from the set\n",
    "## >  set.copy(): Create a copy of the set in a different memory location\n",
    "## >  set1.difference(set2): The returned set contains items that exist only in the first set, and not in both sets.\n",
    "## >  set.union(set1, set2...): returns a set that contains all items from the original set, and all items from the specified set(s). It does not have to be a set, it can be any iterable object.\n",
    "## >  set.intersection(set1, set2 ... etc): It returns a set that contains the similarity between two or more sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()  length: 0\n",
      "{10, 20, 30, 'WELCOME'}  length: 4\n"
     ]
    }
   ],
   "source": [
    "# set.add(object): Adds one object at a time in the set. Accepts only one argument.\n",
    "s1=set()\n",
    "print(s1,\" length:\",len(s1))\n",
    "s1.add(10)\n",
    "s1.add(20)\n",
    "s1.add(30)\n",
    "s1.add(\"WELCOME\")\n",
    "print(s1,\" length:\",len(s1))\n",
    "# s1.add([10,20,30]) # Iterables cannot be added using add()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 40, 10, 'E', 50, 'L', 20, 'H', 30, 'O'} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# set.update(iterable): updates the current set, by adding items from another set \n",
    "# (or any other iterable). We can use any number of iterables in the input argument.\n",
    "s1={10,20,30,40,50}\n",
    "# s1.update(10) # cannot be done as it requires an iterable\n",
    "# for this we need to use add()\n",
    "s1.update(\"HELLO\",[1,2,3,4])\n",
    "print(s1,type(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Welcome', 'To', 'Python'} <class 'set'>\n",
      "{'To', 'Python'} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# set.pop(): Removes a random item from the set. This method returns the removed item.\n",
    "s1={\"Welcome\",\"To\",\"Python\"}\n",
    "print(s1,type(s1))\n",
    "s1.pop() # any random element will be removed\n",
    "print(s1,type(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 50, 20, 30} <class 'set'>\n",
      "{40, 10, 50, 20} <class 'set'>\n",
      "{40, 10, 50, 20} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# set.discard(value): It removes the specified item from the set. This method is different from the remove() method, \n",
    "# because the remove() method will raise an error if the specified item does not exist, and the discard() method will not.\n",
    "s1={10,20,30,40,50}\n",
    "print(s1,type(s1))\n",
    "s1.discard(30)\n",
    "print(s1,type(s1))\n",
    "s1.discard(100) # will not generate any error even if 100 is not in the set\n",
    "print(s1,type(s1)) # the set remains unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 50, 20, 30} <class 'set'>\n",
      "{40, 10, 50, 20} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# set.remove(item): Removes the specified element from the set.\n",
    "# This method is different from the discard() method, because the remove() \n",
    "# method will raise an error if the specified item does not exist, \n",
    "# and the discard() method will not.\n",
    "s1={10,20,30,40,50}\n",
    "print(s1,type(s1))\n",
    "s1.remove(30)\n",
    "print(s1,type(s1))\n",
    "# s1.remove(100) # will generate an error as 100 is not member of set s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 20, 30}  length= 4\n",
      "set()  length= 0\n"
     ]
    }
   ],
   "source": [
    "# set.clear(): Removes all the elements from the set\n",
    "s1={10,20,30,40}\n",
    "print(s1,\" length=\",len(s1))\n",
    "s1.clear()\n",
    "print(s1,\" length=\",len(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 20, 30} 2601128164480\n",
      "{40, 10, 20, 30} 2601128165152\n"
     ]
    }
   ],
   "source": [
    "# set.copy(): Create a copy of the set in a different memory location\n",
    "s1={10,20,30,40}\n",
    "print(s1,id(s1))\n",
    "s2=s1.copy()\n",
    "print(s2,id(s2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 50, 20, 30} {70, 40, 50, 60, 30}\n",
      "{10, 20}\n",
      "{60, 70}\n"
     ]
    }
   ],
   "source": [
    "# set1.difference(set2): The returned set contains items that exist only in the first set, \n",
    "# and not in both sets.\n",
    "s1={10,20,30,40,50}\n",
    "s2={30,40,50,60,70}\n",
    "print(s1,s2)\n",
    "s3=s1.difference(s2)\n",
    "print(s3) # elements in s1 which are not in s2\n",
    "s4=s2.difference(s1)\n",
    "print(s4) # elements in s2 which are not in s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()  length= 0\n",
      "{1, 2, 3, 'M', 'A', 'E', 'C', 'L', 'B', 'W', 'O'}  length= 11\n"
     ]
    }
   ],
   "source": [
    "# set.union(set1, set2...): returns a set that contains all items from the original set, \n",
    "# and all items from the specified set(s). It does not have to be a set, \n",
    "# it can be any iterable object\n",
    "s1=set()\n",
    "print(s1,\" length=\",len(s1))\n",
    "s2=s1.union([1,2,3],\"WELCOME\",{\"A\",\"B\",\"C\"}) # works similar to update()\n",
    "print(s2,\" length=\",len(s2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 10, 50, 20, 30} {70, 40, 50, 60, 30}\n",
      "{40, 50, 30}\n"
     ]
    }
   ],
   "source": [
    "# set.intersection(set1, set2 ... etc): It returns a set that contains the similarity \n",
    "# between two or more sets.\n",
    "s1={10,20,30,40,50}\n",
    "s2={30,40,50,60,70}\n",
    "print(s1,s2)\n",
    "s3=s1.intersection(s2)\n",
    "print(s3) #elements common to both s1 and s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{70, 40, 10, 80, 50, 20, 90, 60, 30} <class 'set'>\n",
      "{2, 4, 6, 8, 10} <class 'set'>\n",
      "{1, 3, 4, 5, 7, 8, 9, 12, 16, 20} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "s1={x for x in range(10,100,10)}\n",
    "print(s1,type(s1)) #insertion order is not preserved (basic property)\n",
    "s2={x for x in range(1,11) if x%2==0}\n",
    "print(s2,type(s2))\n",
    "s3={x if x%2!=0 else 2*x for x in range(1,11)}\n",
    "print(s3,type(s3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['w', 'e', 'l', 'c', 'o', 'm', 'e', ' ', 't', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'n', 'g'] <class 'list'>\n",
      "{'g', 'c', 't', ' ', 'i', 'p', 'o', 'w', 'a', 'y', 'e', 'r', 'h', 'l', 'n', 'm'} <class 'set'>\n",
      "Vowels in the string are: {'o', 'e', 'i', 'a'}\n"
     ]
    }
   ],
   "source": [
    "# WAP to print different vowels present in the given string str1= \"welcome to python programming\". \n",
    "# Use Set data structure. (Hint: use intersection())\n",
    "str1=\"welcome to python programming\"\n",
    "l1=[]\n",
    "l1.extend(str1)\n",
    "print(l1,type(l1))\n",
    "s1=set(l1)\n",
    "print(s1,type(s1))\n",
    "s2=(\"a\",\"e\",\"i\",\"o\",\"u\")\n",
    "print(\"Vowels in the string are:\",s1.intersection(s2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# WAP to remove duplicate elements from a list \n",
    "# and create a new list with those unique elements.\n",
    "l1=[1,1,2,2,3,3,4,4,5,5]\n",
    "l2=list({x for x in l1})\n",
    "print(l2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.7 64-bit",
   "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.10.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "205b98b4d1985d493ef88a03e013826e686053393df5367dcc6e26039158c4c1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}