006_Python_Sets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Datatypes** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/02_Python_Datatypes)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Sets\n",
    "\n",
    "In this class, you'll learn everything about Python sets; how they are created, adding or removing elements from them, and all operations performed on sets in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Set in Python?\n",
    "\n",
    "A set is an **unordered collection of items**. Every set element is unique (no duplicates) and must be immutable (cannot be changed).\n",
    "\n",
    "However, a **set itself is mutable. We can add or remove items from it**.\n",
    "\n",
    "Sets can also be used to perform mathematical set operations like **union**, **intersection**, **symmetric difference**, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## How Are Sets Better Than Other DataTypes?\n",
    "\n",
    "Sets **will not contain multiple occurrences of the same element**, they are very useful in removing duplicate elements from a list or a tuple. Also, they are useful in computing mathematical notations such as union, intersection, etc.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Python Sets\n",
    "\n",
    "A set is created by placing all the items (elements) inside curly braces **`{}`**, separated by comma, or by using the built-in **`set()`** function.\n",
    "\n",
    "It can have any number of items and they may be of different types (integer, float, tuple, string etc.). But a set cannot have mutable elements like **[lists](https://github.com/milaan9/02_Python_Datatypes/blob/main/003_Python_List.ipynb)**, sets or **[dictionaries](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary.ipynb)** as its elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:15.713135Z",
     "start_time": "2021-10-03T14:22:15.702393Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "{1.0, 'Hello', (1, 2, 3)}\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Different types of sets in Python\n",
    "\n",
    "# set of integers\n",
    "my_set = {1, 2, 3}\n",
    "print(my_set)\n",
    "\n",
    "# set of mixed datatypes\n",
    "my_set = {1.0, \"Hello\", (1, 2, 3)}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:16.310326Z",
     "start_time": "2021-10-03T14:22:15.727787Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{1, 2, 3}\n",
      "{1, 2, (3, 4)}\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-5b242263301c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;31m# here [3, 4] is a mutable list\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mmy_set\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m   \u001b[1;31m# this will cause an error.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "# Example 2: Different types of sets in Python\n",
    "\n",
    "# set cannot have duplicates\n",
    "my_set = {1, 2, 3, 4, 3, 2}\n",
    "print(my_set)             # Output: {1, 2, 3, 4}\n",
    "\n",
    "# we can make set from a list\n",
    "my_set = set([1, 2, 3, 2])\n",
    "print(my_set)             # Output: {1, 2, 3}\n",
    "\n",
    "# set can have immutable items\n",
    "# here (3, 4) is a mutable list\n",
    "\n",
    "my_set = {1, 2, (3, 4)}   # {1, 2, (3, 4)}\n",
    "print(my_set) \n",
    "\n",
    "# set cannot have mutable items\n",
    "# here [3, 4] is a mutable list\n",
    "\n",
    "my_set = {1, 2, [3, 4]}   # this will cause an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating an empty set is a bit tricky.\n",
    "\n",
    "Empty curly braces **`{}`** will make an empty dictionary in Python. To make a set without any elements, we use the **`set()`** function without any argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:27.149150Z",
     "start_time": "2021-10-03T14:22:27.142314Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# Example: Distinguish set and dictionary while creating empty set\n",
    "\n",
    "# initialize a with {}\n",
    "a = {}\n",
    "\n",
    "# check data type of a\n",
    "print(type(a))\n",
    "\n",
    "# initialize a with set()\n",
    "a = set()\n",
    "\n",
    "# check data type of a\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying a set in Python\n",
    "\n",
    "Sets are mutable. However, since they are unordered, indexing has no meaning.\n",
    "\n",
    "We cannot access or change an element of a set using indexing or slicing. Set data type does not support it.\n",
    "\n",
    "We can add a single element using the **`add()`** method, and multiple elements using the **`update()`** method. The **`update()`** method can take **[tuples](https://github.com/milaan9/02_Python_Datatypes/blob/main/004_Python_Tuple.ipynb)**, lists, **[strings](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)** or other sets as its argument. In all cases, duplicates are avoided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:27.982190Z",
     "start_time": "2021-10-03T14:22:27.971452Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3}\n",
      "{1, 2, 3}\n",
      "{1, 2, 3, 4}\n",
      "{1, 2, 3, 4, 5, 6, 8}\n"
     ]
    }
   ],
   "source": [
    "# Example: \n",
    "\n",
    "# initialize my_set\n",
    "my_set = {1, 3}\n",
    "print(my_set)\n",
    "\n",
    "# my_set[0]\n",
    "# if you uncomment above line, you will get an error\n",
    "# TypeError: 'set' object does not support indexing\n",
    "\n",
    "# add an element\n",
    "my_set.add(2)\n",
    "print(my_set)     # Output: {1, 2, 3}\n",
    "\n",
    "# add multiple elements\n",
    "my_set.update([2, 3, 4])\n",
    "print(my_set)    # Output: {1, 2, 3, 4}\n",
    "\n",
    "# add list and set\n",
    "my_set.update([4, 5], {1, 6, 8})\n",
    "print(my_set)   # Output: {1, 2, 3, 4, 5, 6, 8}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing elements from a set\n",
    "\n",
    "A particular item can be removed from a set using the methods **`discard()`** and **`remove()`**.\n",
    "\n",
    "The only difference between the two is that the **`discard()`** function leaves a set unchanged if the element is not present in the set. On the other hand, the **`remove()`** function will raise an error in such a condition (if element is not present in the set).\n",
    "\n",
    "The following example will illustrate this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:28.800585Z",
     "start_time": "2021-10-03T14:22:28.731249Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 5, 6}\n",
      "{1, 3, 5, 6}\n",
      "{1, 3, 5}\n",
      "{1, 3, 5}\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "2",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-282b4c81cacb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;31m# remove an element not present in my_set you will get an error.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mmy_set\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# Output: KeyError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 2"
     ]
    }
   ],
   "source": [
    "# Example: Difference between discard() and remove()\n",
    "\n",
    "# initialize my_set\n",
    "my_set = {1, 3, 4, 5, 6}\n",
    "print(my_set)\n",
    "\n",
    "# discard an element\n",
    "my_set.discard(4)\n",
    "print(my_set)     # Output: {1, 3, 5, 6}\n",
    "\n",
    "# remove an element\n",
    "my_set.remove(6)\n",
    "print(my_set)     # Output: {1, 3, 5}\n",
    "\n",
    "# discard an element not present in my_set\n",
    "my_set.discard(2)\n",
    "print(my_set)     # Output: {1, 3, 5}\n",
    "\n",
    "# remove an element not present in my_set you will get an error.\n",
    "my_set.remove(2)  # Output: KeyError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can remove and return an item using the **`pop()`** method.\n",
    "\n",
    "Since set is an unordered data type, there is no way of determining which item will be popped. It is completely arbitrary.\n",
    "\n",
    "We can also remove all the items from a set using the **`clear()`** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:29.430491Z",
     "start_time": "2021-10-03T14:22:29.419752Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'r', 'H', 'l', 'e', 'd', 'W', 'o'}\n",
      "r\n",
      "{'l', 'e', 'd', 'W', 'o'}\n",
      "set()\n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "# initialize my_set\n",
    "my_set = set(\"HelloWorld\")\n",
    "print(my_set)        # Output: set of unique elements\n",
    "\n",
    "# pop an element\n",
    "print(my_set.pop())  # Output: random element\n",
    "\n",
    "# pop another element\n",
    "my_set.pop()\n",
    "print(my_set)\n",
    "\n",
    "# clear my_set\n",
    "my_set.clear()\n",
    "print(my_set)        # Output: set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Set Operations\n",
    "\n",
    "Sets can be used to carry out mathematical set operations like union, intersection, difference and symmetric difference. We can do this with operators or methods.\n",
    "\n",
    "Let us consider the following two sets for the following operations.\n",
    "\n",
    "```python\n",
    ">>> A = {1, 2, 3, 4, 5}\n",
    ">>> B = {4, 5, 6, 7, 8}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Union\n",
    "\n",
    "<div>\n",
    "<img src=\"img/set1.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "Union of **`A`** and **`B`** is a set of all elements from both sets.\n",
    "\n",
    "Union is performed using **`|`** operator. Same can be accomplished using the **`union()`** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:30.141458Z",
     "start_time": "2021-10-03T14:22:30.132671Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "# Set union method\n",
    "# initialize A and B\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "\n",
    "# use | operator\n",
    "print(A | B)      # Output: {1, 2, 3, 4, 5, 6, 7, 8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:30.448112Z",
     "start_time": "2021-10-03T14:22:30.422721Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "# use union function\n",
    "A.union(B)\n",
    "{1, 2, 3, 4, 5, 6, 7, 8}\n",
    "\n",
    "# use union function on B\n",
    "B.union(A)\n",
    "{1, 2, 3, 4, 5, 6, 7, 8}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Intersection\n",
    "\n",
    "<div>\n",
    "<img src=\"img/set2.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "Intersection of **`A`** and **`B`** is a set of elements that are common in both the sets.\n",
    "\n",
    "Intersection is performed using **`&`** operator. Same can be accomplished using the **`intersection()`** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:30.802129Z",
     "start_time": "2021-10-03T14:22:30.787484Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4, 5}\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "# Intersection of sets\n",
    "# initialize A and B\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "\n",
    "# use & operator\n",
    "print(A & B)     # Output: {4, 5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:31.048238Z",
     "start_time": "2021-10-03T14:22:31.030656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "# use intersection function on A\n",
    "A.intersection(B)\n",
    "{4, 5}\n",
    "\n",
    "# use intersection function on B\n",
    "B.intersection(A)\n",
    "{4, 5}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Difference\n",
    "\n",
    "<div>\n",
    "<img src=\"img/set3.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "Difference of the set **`B`** from set **`A`**, **`(A - B)`** is a set of elements that are only in A but not in **`B`**. Similarly, **`B - A`** is a set of elements in **`B`** but not in **`A`**.\n",
    "\n",
    "Difference is performed using **`-`** operator. Same can be accomplished using the **`difference()`** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:31.508218Z",
     "start_time": "2021-10-03T14:22:31.491614Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "# Difference of two sets\n",
    "# initialize A and B\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "\n",
    "# use - operator on A\n",
    "print(A - B)    # Output: {1, 2, 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:31.755293Z",
     "start_time": "2021-10-03T14:22:31.735763Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "# use difference function on A\n",
    "A.difference(B)\n",
    "{1, 2, 3}\n",
    "\n",
    "# use - operator on B\n",
    "B - A\n",
    "{8, 6, 7}\n",
    "\n",
    "# use difference function on B\n",
    "B.difference(A)\n",
    "{8, 6, 7}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Symmetric Difference\n",
    "\n",
    "<div>\n",
    "<img src=\"img/set4.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "Symmetric Difference of **`A`** and **`B`** is a set of elements in **`A`** and **`B`** but not in both (excluding the intersection).\n",
    "\n",
    "Symmetric difference is performed using **`^`** operator. Same can be accomplished using the method **`symmetric_difference()`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:32.248479Z",
     "start_time": "2021-10-03T14:22:32.227973Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "# Symmetric difference of two sets\n",
    "# initialize A and B\n",
    "A = {1, 2, 3, 4, 5}\n",
    "B = {4, 5, 6, 7, 8}\n",
    "\n",
    "# use ^ operator\n",
    "print(A ^ B)    # Output: {1, 2, 3, 6, 7, 8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:32.556109Z",
     "start_time": "2021-10-03T14:22:32.533649Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 6, 7, 8}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "# use symmetric_difference function on A\n",
    "A.symmetric_difference(B)\n",
    "{1, 2, 3, 6, 7, 8}\n",
    "\n",
    "# use symmetric_difference function on B\n",
    "B.symmetric_difference(A)\n",
    "{1, 2, 3, 6, 7, 8}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Functions with Set\n",
    "\n",
    "Built-in functions like **`all()`**, **`any()`**, **`enumerate()`**, **`len()`**, **`max()`**, **`min()`**, **`sorted()`**, **`sum()`**, etc. are commonly used with sets to perform different tasks.\n",
    "\n",
    "| Function | Description | \n",
    "|:---- |:---- |\n",
    "| ****[all()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/003_Python_all%28%29.ipynb)**** | Returns **`True`** if all elements of the set are true (or if the set is empty). |\n",
    "| **[any()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/002_Python_any%28%29.ipynb)** | Returns **`True`** if any element of the set is true. If the set is empty, returns **`False`**. |\n",
    "| **[enumerate()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/018_Python_enumerate%28%29.ipynb)** | Returns an enumerate object. It contains the index and value for all the items of the set as a pair. |\n",
    "| **[len()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/040_Python_len%28%29.ipynb)** | Returns the length (the number of items) in the set. |\n",
    "| **[max()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/041_Python_max%28%29.ipynb)** | Returns the largest item in the set. |\n",
    "| **[min()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/042_Python_min%28%29.ipynb)** | Returns the smallest item in the set. |\n",
    "| **[sorted()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/060_Python_sorted%28%29.ipynb)** | Returns a new sorted list from elements in the set(does not sort the set itself). |\n",
    "| **[sum()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/062_Python_sum%28%29.ipynb)** | Returns the sum of all elements in the set. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Python Set Methods\n",
    "\n",
    "There are many set methods, some of which we have already used above. Here is a list of all the methods that are available with the set objects:\n",
    "\n",
    "| Method | Operator | Description |\n",
    "|:---- |:---- |:--- |\n",
    "| **[add()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/002_Python_Set_add%28%29.ipynb)** |  |  Adds an element to the set. | \n",
    "| **[copy()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/003_Python_Set_copy%28%29.ipynb)** |  |  Returns a copy of the set. | \n",
    "| **[remove()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/001_Python_Set_remove%28%29.ipynb)** |  |  Removes an element from the set. If the element is not a member, raises a **`KeyError`**. |\n",
    "| **[discard()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/007_Python_Set_discard%28%29.ipynb)** |  |  Removes an element from the set if it is a member. (Do nothing if the element is not in set). | \n",
    "| **[pop()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/013_Python_Set_pop%28%29.ipynb)** |  |  Removes and returns an arbitrary set element. Raises **`KeyError`** if the set is empty. | \n",
    "| **[clear()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/004_Python_Set_clear%28%29.ipynb)** |  |  Removes all elements from the set. | \n",
    "| **[union()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/016_Python_Set_union%28%29.ipynb)** | **`A \\| B`** |  Returns the union of sets in a new set. | \n",
    "| **[update()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/017_Python_Set_update%28%29.ipynb)** | **`A \\|= B`** |  Updates the set with the union of itself and others. | \n",
    "| **[intersection()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/008_Python_Set_intersection%28%29.ipynb)** | **`A & B`** |  Returns the intersection of two sets as a new set. | \n",
    "| **[intersection_update()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/009_Python_Set_intersection_update%28%29.ipynb)** | **`A &= B`** |  Updates the set with the intersection of itself and another. | \n",
    "| **[isdisjoint()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/010_Python_Set_isdisjoint%28%29.ipynb)** |  |  Returns **`True`** if two sets have a null intersection. | \n",
    "| **[difference()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/005_Python_Set_difference%28%29.ipynb)** | **`A – B`** |  Returns the difference of two or more sets as a new set. | \n",
    "| **[difference_update()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/006_Python_Set_difference_update%28%29.ipynb)** | **`A -= B`** |  Removes all elements of another set from this set. | \n",
    "| **[symmetric_difference()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/014_Python_Set_symmetric_difference%28%29.ipynb)** | **`A ^ B`** |  Returns the symmetric difference of two sets as a new set. | \n",
    "| **[symmetric_difference_update()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/015_Python_Set_symmetric_difference_update%28%29.ipynb)** | **`A ^= B`** |  Updates a set with the symmetric difference of itself and another. | \n",
    "| **[issubset()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/011_Python_Set_issubset%28%29.ipynb)** | **`A <= B`** |  Returns **`True`** if another set contains this set. | \n",
    "| **[issuperset()](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets_Methods/012_Python_Set_issuperset%28%29.ipynb)** | **`A >= B`** | Returns **`True`** if this set contains another set. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a complete list of all the **[built-in methods to work with Sets in Python](https://github.com/milaan9/02_Python_Datatypes/tree/main/006_Python_Sets_Methods)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Set Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Set Membership Test\n",
    "\n",
    "We can test if an item exists in a set or not, using the **`in`** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:34.602087Z",
     "start_time": "2021-10-03T14:22:34.588419Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "# in keyword in a set\n",
    "# initialize my_set\n",
    "my_set = set(\"apple\")\n",
    "\n",
    "# check if 'a' is present\n",
    "print('a' in my_set)      # Output: True\n",
    "\n",
    "# check if 'p' is present\n",
    "print('p' not in my_set)  # Output: False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Iterating Through a Set\n",
    "\n",
    "We can iterate through each item in a set using a **`for`** loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:35.248600Z",
     "start_time": "2021-10-03T14:22:35.228094Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "a\n",
      "e\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "for letter in set(\"apple\"):\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Frozenset\n",
    "\n",
    "Frozenset is a new class that has the characteristics of a set, but its elements cannot be changed once assigned. While tuples are immutable lists, frozensets are immutable sets.\n",
    "\n",
    "Sets being mutable are unhashable, so they can't be used as dictionary keys. On the other hand, frozensets are hashable and can be used as keys to a dictionary.\n",
    "\n",
    "Frozensets can be created using the **[frozenset()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/024_Python_frozenset%28%29.ipynb)** function.\n",
    "\n",
    "The **`frozenset()`** function returns an immutable frozenset object initialized with elements from the given iterable.\n",
    "\n",
    "This data type supports methods like **`copy()`**, **`difference()`**, **`intersection()`**, **`isdisjoint()`**, **`issubset()`**, **`issuperset()`**, **`symmetric_difference()`** and **`union()`**. Being immutable, it does not have methods that add or remove elements.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "frozenset([iterable])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:35.835536Z",
     "start_time": "2021-10-03T14:22:35.820892Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example:\n",
    "\n",
    "# Frozensets\n",
    "# initialize A and B\n",
    "A = frozenset([1, 2, 3, 4])\n",
    "B = frozenset([3, 4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:36.376573Z",
     "start_time": "2021-10-03T14:22:36.356070Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.isdisjoint(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:36.623658Z",
     "start_time": "2021-10-03T14:22:36.613892Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset({1, 2})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.difference(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:36.885384Z",
     "start_time": "2021-10-03T14:22:36.871715Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset({1, 2, 3, 4, 5, 6})"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A | B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:37.161762Z",
     "start_time": "2021-10-03T14:22:37.133444Z"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'frozenset' object has no attribute 'add'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-a0e0b3f02a4a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mA\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'"
     ]
    }
   ],
   "source": [
    "A.add(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frozenset methods\n",
    "\n",
    "This data type supports methods like **`copy()`**, **`union()`**, **`intersection()`**, **`difference()`**, and **`symmetric_difference()`**. Being immutable, it does not have methods that add or remove elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:37.685219Z",
     "start_time": "2021-10-03T14:22:37.667647Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frozenset({1, 2, 3, 4})\n",
      "frozenset({1, 2, 3, 4, 5, 6})\n",
      "frozenset({3, 4})\n",
      "frozenset({1, 2})\n",
      "frozenset({1, 2, 5, 6})\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Frozensets\n",
    "\n",
    "# initialize A and B\n",
    "A = frozenset([1, 2, 3, 4])\n",
    "B = frozenset([3, 4, 5, 6])\n",
    "\n",
    "# copying a frozenset\n",
    "C = A.copy()              # Output: frozenset({1, 2, 3, 4})\n",
    "print(C)\n",
    "\n",
    "# union\n",
    "print(A.union(B))         # Output: frozenset({1, 2, 3, 4, 5, 6})\n",
    "\n",
    "# intersection\n",
    "print(A.intersection(B))  # Output: frozenset({3, 4})\n",
    "\n",
    "# difference\n",
    "print(A.difference(B))    # Output: frozenset({1, 2})\n",
    "\n",
    "# symmetric_difference\n",
    "print(A.symmetric_difference(B))  # Output: frozenset({1, 2, 5, 6})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Frozenset methods \n",
    "\n",
    "Similarly, other set methods like **`isdisjoint()`**, **`issubset()`**, and **`issuperset()`** are also available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T14:22:38.254095Z",
     "start_time": "2021-10-03T14:22:38.237492Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Frozensets\n",
    "\n",
    "# initialize A, B and C\n",
    "A = frozenset([1, 2, 3, 4])\n",
    "B = frozenset([3, 4, 5, 6])\n",
    "C = frozenset([5, 6])\n",
    "\n",
    "# isdisjoint() method\n",
    "print(A.isdisjoint(C))  # Output: True\n",
    "\n",
    "# issubset() method\n",
    "print(C.issubset(B))    # Output: True\n",
    "\n",
    "# issuperset() method\n",
    "print(B.issuperset(C))  # Output: True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Sets</span>\n",
    "\n",
    "```py\n",
    "mix_fruits = {'Guava', 'Pear', 'Mango', 'Apple', 'Fig', 'Orange', 'Banana'}\n",
    "A = {19, 22, 24, 20, 25, 26}\n",
    "B = {19, 22, 20, 25, 26, 24, 28, 27}\n",
    "num = [22, 19, 24, 25, 26, 24, 25, 24]\n",
    "```\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Find the length of the set **`mix_fruits`**\n",
    "2. Add **`'Kiwi'`** to **`mix_fruits`**\n",
    "3. Insert multiple fruits at once to the set **`mix_fruits`**\n",
    "4. Remove one of the fruit from the set **`mix_fruits`**\n",
    "5. What is the difference between **remove** and **discard**\n",
    "\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "Use Imaginary values for Set **`A`** and **`B`**\n",
    "\n",
    "1. Join **`A`** and **`B`**\n",
    "2. Find **`A`** intersection **`B`**\n",
    "3. Is **`A`** subset of **`B`**\n",
    "4. Are **`A`** and **`B`** disjoint sets\n",
    "5. Join **`A`** with **`B`** and **`B`** with **`A`**\n",
    "6. What is the symmetric difference between A and **`B`**\n",
    "7. Delete the sets completely\n",
    "\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 3</span>\n",
    "\n",
    "1. Convert the **`num`** to a set and compare the length of the list and the set, which one is bigger?\n",
    "2. Explain the difference between the following data types: **string**, **list**, **tuple** and **set**\n",
    "3. **`I am a researcher cum teacher and I love to inspire and teach people.`**. How many unique words have been used in the sentence? Use the **`split`** methods and set to get the unique words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}