G7.Set_built.in.function.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PROGRAM ON SET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'geek', 'for'}\n",
      "{'l', 'h', 'o', 'e'}\n"
     ]
    }
   ],
   "source": [
    "# A set cannot have duplicate values( it will hold only unique values).\n",
    "\n",
    "set={\"geek\",\"for\",\"geek\"} \n",
    "print(set)\n",
    "set={\"h\",\"e\",\"l\",\"l\",\"o\"}\n",
    "print(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'to', 'traning', 'well', 'center', 'hi', 'come', 'keonics'}\n"
     ]
    }
   ],
   "source": [
    "#  A set can store hetrogeneous elements(set are unorder in seq.) \n",
    "\n",
    "myset={\"hi\",\"well\",\"come\",\"to\",\"keonics\",\"traning\",\"center\"}\n",
    "print(myset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'s', 'popale', 'Gourav'}\n"
     ]
    }
   ],
   "source": [
    "# Adding a string in a set,\n",
    "\n",
    "set ={\"Gourav\",\"popale\"}\n",
    "set.add(\"s\")\n",
    "print(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ralph lauren', 'lactose', 'apple', 'google'}\n"
     ]
    }
   ],
   "source": [
    "# using update in set\n",
    "\n",
    "set1={'lactose','ralph lauren'}\n",
    "set2={'apple','google','apple'}\n",
    "\n",
    "set1.update(set2)\n",
    "#  whole set2 will update in set1\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'popale', 'Gourav'}\n"
     ]
    }
   ],
   "source": [
    "# Using Discard in set\n",
    "\n",
    "set1={'Gourav','s','popale'}\n",
    "set1.discard('s')\n",
    "#  and also we can use remove().function\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Find Number of set Elements     \n",
    "\n",
    "set_number={1,2,3,4,5,6,7,8,9,1,2,3}\n",
    "\n",
    "#it will not count repeated value again and again\n",
    "print(len(set_number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "# Using intersection in set  \n",
    "\n",
    "et1={1,2,3,4,5}\n",
    "set2={7,6,2,5,8}\n",
    "print(set1.intersection(set2))\n",
    "# it will just take (common) values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "#  Using Symmetric_difference in set  \n",
    "\n",
    "setA={1,2,3,4,5}\n",
    "setB={7,6,2,5,8}\n",
    "print(setA.symmetric_difference(setB))\n",
    "#the common values will not print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Adding values in set using for loop\n",
    "\n",
    "set1=set()\n",
    "set1.add(6)\n",
    "for i in range(1,6):\n",
    "    set1.add(i)\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  using clearing sets\n",
    "\n",
    "set1={1,2,3,4,5,6}\n",
    "# set1\n",
    "set1.clear()\n",
    "set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "# to print union set by using function and operator\n",
    "setg={1,2,3,4,5}\n",
    "sets={6,7,8,9,10}\n",
    "# by function\n",
    "set1=setg.union(sets)\n",
    "set1\n",
    "# by operator\n",
    "print(setg|sets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#  program to check set1 is equivalent to set2 by using operator\n",
    "set1={1,2,3,4,5}\n",
    "set2={1,2,3,4,5}\n",
    "# if element are same thn it is equivalent\n",
    "# equivalent operator\n",
    "print(set1 == set2)\n",
    "# if it is equivalent it prints (True)\n",
    "\n",
    "# if set1 is not equivalent to set2 by using opreator\n",
    "\n",
    "set1={1,2,3,4,5}\n",
    "set2={6,7,8,9,10}\n",
    "#  if it is not equivalent to set2 (thn it prints True)\n",
    "print(set1!=set2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#  program to print (subset) of elements with operator\n",
    "# subset\n",
    "s1={\"gourav\",\"1650\",\"frooti\"}\n",
    "s2={\"gourav\",\"1650\",\"frooti\"}\n",
    "# A set A is a subset of another set B if all elements of the set A are elements of the set B.\n",
    "print(s1<=s2)\n",
    "\n",
    "#  program to print propersubset of element\n",
    "s1={1,2,3,4,5}\n",
    "s2={6,8,9,10,1,2,3,4,5}\n",
    "# A proper subset is one that contains a few elements of the original set\n",
    "print(s1<s2)\n",
    "\n",
    "# program to print (superset) \n",
    "s1={1,2,3,4}\n",
    "s2={1,2,3,4,5,6,7,8,9} # same has subset\n",
    "print(s1>=s2)\n"
   ]
  }
 ],
 "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}