DS_Sets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures or Derived data Types in Python:\n",
    "\n",
    "Storing multiple values of same or different types under a single name.\n",
    "They are collection of data.\n",
    "\n",
    "1. List\n",
    "2. Tuple\n",
    "3. String\n",
    "4. Dictionary\n",
    "5. Set  \n",
    "In this notebook, we'll discuss indepth on Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets:\n",
    "Sets are unordered collection of unique data.\n",
    "Enclosed by Curly braces `{}`  \n",
    "\n",
    "```python\n",
    "set: {10, 20.2, 30.0}\n",
    "```\n",
    "\n",
    "Each value in the set is called a element  \n",
    "Since set is unordered collection, it cannot be indexed. The elements are randomly stored."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a set:\n",
    "\n",
    "### set() method\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "set(iterable = None)\n",
    "```  \n",
    "iterable: any data structures listed above  \n",
    "\n",
    "By default the `{}` map to a dictionary. So empty curly braces cannot be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 20, 30}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [10, 20, 30]\n",
    "s = set(l)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 20, 30}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = {10, 20, 30, 10, 30}\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting set as input:\n",
    "```python\n",
    "s1 = set(input())  \n",
    "s2 = set(input().split())\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods or Functions in sets:\n",
    "There are various methods or functions that are used to work on sets.  \n",
    "1. add  \n",
    "2. update   \n",
    "3. discard  \n",
    "4. pop  \n",
    "5. clear  \n",
    "6. len  \n",
    "7. issubset  \n",
    "8. issuperset  \n",
    "9. union  \n",
    "10. intersection  \n",
    "11. intersection_update  \n",
    "12. difference  \n",
    "13. symmetric_difference  \n",
    "14. copy  \n",
    "15. isdisjoint  \n",
    "16. max  \n",
    "17. min  \n",
    "18. enumerate\n",
    "19. sum\n",
    "20. sorted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. add:\n",
    "Adds an element to the end of the set.\n",
    "\n",
    "Syntax: `set.add(element)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 20, 30, 40}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set1.add(40)\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. update:\n",
    "Adds elements in another set to given set\n",
    "\n",
    "Syntax: `set.update(set)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 20, 25, 30, 40}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {10, 25, 40}\n",
    "set1.update(set2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. discard:\n",
    "Discards the given element in the set.\n",
    "\n",
    "Syntax: `set.discard(element)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 30}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set1.discard(20)\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. pop:\n",
    "Removes and returns a random element from set.\n",
    "\n",
    "Syntax: `set.pop()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set1.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. clear:\n",
    "Empties the set.\n",
    "\n",
    "Syntax: `set.clear()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set1.clear()\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. len\n",
    "Returns the length of the set\n",
    "\n",
    "Syntax: `len(set)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. issubset:\n",
    "Checks if a set subset of another.\n",
    "\n",
    "Syntax: `set.issubset(set)`  \n",
    "Or set1 <= set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {10, 20}\n",
    "set2.issubset(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. issuperset:\n",
    "Checks if the set superset of another.\n",
    "\n",
    "Syntax: `set.issuperset(set)`  \n",
    "Or set1 >= set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {10, 20, 30, 35}\n",
    "set2.issuperset(set1) # set1.issubset(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. union:\n",
    "Returns the union of 2 sets\n",
    "\n",
    "Syntax: `set.union(set)`  \n",
    "Or set1|set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 12, 20, 22, 30}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1.union(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 12, 20, 22, 30}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1|set2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. intersection:\n",
    "Returns the intersection of 2 sets\n",
    "\n",
    "Syntax: `set.intersection(set2)`  \n",
    "Or set1 & set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{30}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1.intersection(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{30}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1 & set2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. intersection_update:\n",
    "Updates the set with intersection of given set.\n",
    "\n",
    "Syntax: `set.intersection_update(set)`  \n",
    "Or set1 &= set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{30}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1.intersection_update(set2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{30}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1 &= set2\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. difference:\n",
    "Returns the set difference of given set\n",
    "\n",
    "Syntax: `set1-set2`  \n",
    "Or set1 - set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 20}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1.difference(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13. Symmetric Difference:\n",
    "Returns the symmetric difference of two sets.\n",
    "\n",
    "Syntax: `set.symmetric_difference(set)`\n",
    "Or set1 ^ set2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 12, 20, 22}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {12, 22, 30}\n",
    "set1.symmetric_difference(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14. copy:\n",
    "Copies a set\n",
    "\n",
    "Syntax: `set.copy()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10, 20, 30}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = set1.copy()\n",
    "set2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15. isdisjoint:\n",
    "Checks if the given sets are mutually exclusive.\n",
    "\n",
    "Syntax: `set.isdisjoint(set)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "set2 = {1, 22, -37}\n",
    "set1.isdisjoint(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [10, -10, 20, -30, 40]\n",
    "sum(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 16. max:\n",
    "Returns the maximum value in the set.\n",
    "\n",
    "Syntax: `max(set, key = None)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = {10, 15, 50, 21, -7}\n",
    "max(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = {10, 15, 50, 21, -7, 7}\n",
    "max(l, key = lambda x: x % 5) # Maximum reminder when divided by 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 17. min:\n",
    "Returns minimum value in the iterable\n",
    "\n",
    "Syntax: `min(iterable, key = None)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = {10, 15, 50, 21, -7}\n",
    "min(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18. enumerate:\n",
    "Returns the enumerate object for given set. An enumerate object is an iterable which contains ordered pair of the form `(index, value)`  \n",
    "\n",
    "Syntax: `enumerate(iterable, start = 0)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 10), (1, 'Hello'), (2, 20), (3, 'a'), (4, -1)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = {10, 20, 'Hello', 'a', -1}\n",
    "list(enumerate(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 19. sum:\n",
    "returns the sum elements in the set.\n",
    "\n",
    "Syntax: `sum(set, start = 0)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 20. sorted:\n",
    "It is a function used to sort.\n",
    "\n",
    "Syntax: `sorted(iterable, key = None, reverse = False)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing the elements in a set:\n",
    "1. Using loops\n",
    "2. Using Variable length argument ( * )\n",
    "\n",
    "### 1. Looping:\n",
    "Use for loop to access element.\n",
    "\n",
    "### 2. Using * :\n",
    "Using * will convert the elements of into arguements of print method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "for i in set1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30\n"
     ]
    }
   ],
   "source": [
    "set1 = {10, 20, 30}\n",
    "print(*set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 = set(i+1 for i in range(0, 10))\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## all and any:\n",
    "*any* checks if any of the element in an iterable is true.\n",
    "\n",
    "*all* checks if all the element on an iterable is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "l = [10, 20, 30, 0]\n",
    "print(any(l))\n",
    "print(all(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "set1 = {10, 20, 30, -1}\n",
    "print(any(set1))\n",
    "print(all(set1))"
   ]
  }
 ],
 "metadata": {
  "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}