01 DATA-TYPES.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data types in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keywords in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n",
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(len(keyword.kwlist))\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address of a:  140710898512768\n"
     ]
    }
   ],
   "source": [
    "a=100\n",
    "print(\"Address of a: \",id(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data types in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### int, float, complex, bool, str, bytes, bytearray, range, list, tuple, set, frozenset, dict, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytearray'>\n",
      "10\n",
      "100\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "a=bytearray([10,20,30])\n",
    "print(type(a))\n",
    "a[1]=100\n",
    "for x in a:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "a=range(5,10)\n",
    "print(type(a))\n",
    "for x in a:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "l1=[1,2,3,4,5,6]\n",
    "print(type(l1))\n",
    "for x in l1:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integer data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "-15\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Binary\n",
    "a=0b1111 # or 0B1111\n",
    "print(a)\n",
    "a=-0B1111\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "585\n"
     ]
    }
   ],
   "source": [
    "# Octal\n",
    "a=0o1111  # or 0O1111\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "# Hexadecimal\n",
    "a=0xF  # or 0XF\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1111\n",
      "0b1010011\n",
      "0b101010111100\n",
      "0o17\n",
      "0o123\n",
      "0o5274\n",
      "0xf\n",
      "0x53\n",
      "0xabc\n"
     ]
    }
   ],
   "source": [
    "# 4 types of integers: decimal,binary,octal and hexadecimal\n",
    "# bin(), oct(), hex() used to convert any type of data\n",
    "print(bin(15))\n",
    "print(bin(0o123))\n",
    "print(bin(0xabc))\n",
    "print(oct(15))\n",
    "print(oct(0o123))\n",
    "print(oct(0xabc))\n",
    "print(hex(15))\n",
    "print(hex(0o123))\n",
    "print(hex(0xabc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float data type\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Binary, Octal and Hexadecimal not applicable to floating data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123.456 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "f=123.456\n",
    "print(f,type(f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex data type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### format: a + bj, where a is real part, b is imaginary part and j^2=-1 or j=srt(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10+20j) <class 'complex'>\n",
      "(10.5+20.4j) <class 'complex'>\n",
      "Real part: 10.5\n",
      "Imaginary part: 20.4\n"
     ]
    }
   ],
   "source": [
    "c=10+20j \n",
    "print(c,type(c))\n",
    "d=10.5+20.4j\n",
    "print(d,type(d))\n",
    "print(\"Real part:\",d.real)\n",
    "print(\"Imaginary part:\",d.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean data type: bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### the only allowed values are: True and False\n",
    "#### internally True is =1 and False is =0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True <class 'bool'>\n",
      "False <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a=True\n",
    "b=False\n",
    "print(a,type(a))\n",
    "print(b,type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "b=20\n",
    "c=a>b\n",
    "print(c,type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(True+True+True) //internally True=1\n",
    "print(False+False+False) //internally False=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'str' data type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### any value enclosed within single ('') or double (\"\") quotes is treated as String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python <class 'str'>\n",
      "Python <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s1='Python'\n",
    "s2=\"Python\"\n",
    "print(s1,type(s1))\n",
    "print(s2,type(s2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is \n",
      "a multiline\n",
      "String <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# Multi-line string object: three single or double quotes\n",
    "s1='''This is \n",
    "a multiline\n",
    "String'''\n",
    "print(s1,type(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is \"Python\" String <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s1='''This is \"Python\" String'''\n",
    "print(s1,type(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Indexing on String\n",
    "s1=\"Python\"\n",
    "print(s1[0])\n",
    "print(s1[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "### > [begin_index : end_index : step_value]\n",
    "### > if begin_index or end_index or both are -ve then both are converted to equivalent -ve indexes internally and then evaluated\n",
    "### When begin_index, end_index and step_value are not given then:<br/> > default value of begin_index is 0 <br/> > default value of end_index is length of the series or collection <br/> > default value of step_value is 1\n",
    "### When begin_index and end_index are not given and step_value is -ve then:<br/> > default value of begin_index is -1 <br/> > default value of end_index is   -(length of series + 1)\n",
    "### When step_value is positive then  <br/> > slicing is done in forward direction from begin_index to end_index-1  <br/> > Important condition:  begin_index &leq; end_index-1\n",
    "### When step_value is negative then  <br/> > slicing is done in reverse direction from begin_index to end_index+1  <br/> > Important condition: the finally calculated begin_index &GreaterEqual; end_index+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0123456789 String length:  10\n",
      "0123\n",
      "23456789\n",
      "01234\n",
      "0123456789\n",
      "\n",
      "567\n",
      "135\n",
      "765432\n",
      "o/p:  987654\n",
      "o/p:  7654\n",
      "o/p:  3\n",
      "o/p:  \n",
      "o/p:  4\n"
     ]
    }
   ],
   "source": [
    "### Slicing on String\n",
    "\n",
    "# includes the begin-index and goes one before end-index\n",
    "s1=\"0123456789\"\n",
    "print(s1,\"String length: \",len(s1))\n",
    "print(s1[0:4])\n",
    "print(s1[2:]) #from index 2 to end\n",
    "print(s1[:5]) #from begin to index 4  (5-1)\n",
    "print(s1[:]) #from begin to end\n",
    "print(s1[-2:-5]) # no output as begin index should be < end index, here its not\n",
    "print(s1[-5:-2]) # from -5 to -3\n",
    "# [begin:end:step]\n",
    "print(s1[1:7:2]) # begin to end-1 as step is +ve\n",
    "print(s1[7:1:-1]) # begin to end+1 as step is -ve\n",
    "print(\"o/p: \",s1[9:-7:-1])\n",
    "print(\"o/p: \",s1[-3:3:-1])\n",
    "print(\"o/p: \",s1[3:-8:-1])\n",
    "print(\"o/p: \",s1[7:-1:-1])\n",
    "print(\"o/p: \",s1[4:5:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any string: 12345\n",
      "at index[0]or[-5] = 1\n",
      "at index[1]or[-4] = 2\n",
      "at index[2]or[-3] = 3\n",
      "at index[3]or[-2] = 4\n",
      "at index[4]or[-1] = 5\n"
     ]
    }
   ],
   "source": [
    "# WAP to print positive and negative index of all characters present in a string\n",
    "s1=input(\"Enter any string: \")\n",
    "ln=len(s1)\n",
    "for x in range(ln):\n",
    "    print(\"at index[{}]or[{}] = {}\".format(x,x-ln,s1[x]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "nohtyP\n"
     ]
    }
   ],
   "source": [
    "# WAP to print forward and reverse of a string using slicing\n",
    "s1=\"Python\"\n",
    "print(s1[:])\n",
    "print(s1[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type casting functions\n",
    "#### int(), complex(), float(), bool(), str()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n",
      "123\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# int()\n",
    "print(int(123.456))\n",
    "print(int(\"123\"))\n",
    "# print(int(\"10.5\")) error, as only integers inside the string allowed\n",
    "print(int(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.0\n",
      "123.345\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# float()\n",
    "print(float(100))\n",
    "print(float(\"123.345\"))\n",
    "print(float(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10+0j)\n",
      "(10+20j)\n",
      "(30+0j)\n",
      "(1+0j)\n",
      "(1+0j)\n"
     ]
    }
   ],
   "source": [
    "# complex()\n",
    "print(complex(10)) # 10+0j\n",
    "print(complex(10,20)) # 10+20j\n",
    "print(complex(\"30\"))\n",
    "print(complex(True))\n",
    "print(complex(True,False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# bool()\n",
    "print(bool(10))\n",
    "print(bool(-10))\n",
    "print(bool(0))\n",
    "print(bool(1.5))\n",
    "print(bool('123'))\n",
    "print(bool(''))  # null string so False\n",
    "print(bool(' ')) # non-null string so True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'is' operator for comparing references\n",
    "#### it compares the identity of two object references"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140705264379968 140705264379968\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x=10\n",
    "y=10\n",
    "print(id(x),id(y))\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2419026972784 2419026973360\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x=257\n",
    "y=257\n",
    "print(id(x),id(y)) # different references will be given if value exceeds 0 to 256\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2419026973712 2419026972784\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x=2.5\n",
    "y=2.5\n",
    "print(id(x),id(y)) # for floating point always different references are used\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2419027051312 2419027051312\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x=\"ABCD345\"\n",
    "y=\"ABCD345\"\n",
    "print(id(x),id(y)) # for same string values same reference is used\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'bytes' data type\n",
    "#### > used to represent an array of integer byte values\n",
    "#### > each value should be in the range of 0 to 256\n",
    "#### > it is immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "<class 'bytes'>\n"
     ]
    }
   ],
   "source": [
    "a=[10,20,30]\n",
    "b=bytes(a)\n",
    "for x in b:\n",
    "    print(x)\n",
    "print(type(b))\n",
    "# b[0]=100 # Error as bytes object is immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'bytearray' data type\n",
    "#### same as bytes data type but it is mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "10\n",
      "111\n",
      "30\n",
      "<class 'bytearray'>\n"
     ]
    }
   ],
   "source": [
    "a=[10,20,30]\n",
    "b=bytearray(a)\n",
    "for x in b: print(x)\n",
    "b[1]=111\n",
    "for x in b: print(x)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'list' data type\n",
    "#### > dynamic array (mutable) of heterogenous values/objects <br/> > insertion order is preserved (indexable) <br/> > duplicates allowed <br/> > slicing operations allowed (subscriptable) <br/> > symbol: []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[123, 123, 'abc', None]\n",
      "[123, 'abc']\n",
      "[123, 'abc']\n",
      "[123, 999, 'abc', None]\n",
      "10\n",
      "[1, 2, 3]\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "l=[]\n",
    "print(type(l))\n",
    "l.append(123)\n",
    "l.append(123)\n",
    "l.append('abc')\n",
    "l.append(None)\n",
    "print(l)\n",
    "print(l[1:3])\n",
    "print(l[-3:-1])\n",
    "l[1]=999\n",
    "print(l)\n",
    "l2=[10,[1,2,3],20]\n",
    "for x in l2: print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'tuple' data type\n",
    "#### > fixed size array (immutable) of heterogenous values/objects <br/> > insertion order is preserved (indexable) <br/> > duplicates allowed <br/> > slicing operations allowed (subscriptable) <br/> > symbol: ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(10, 10, 20, 30, 40)\n",
      "30\n",
      "(10, 10, 20)\n",
      "(20, 30)\n",
      "10\n",
      "[1, 2, 3]\n",
      "(5, 6, 7)\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "t=(10,10,20,30,40)\n",
    "print(type(t))\n",
    "print(t)\n",
    "print(t[3])\n",
    "print(t[0:3])\n",
    "print(t[-3:-1])\n",
    "# t[0]=999  error: as tuple is immutable\n",
    "t2=(10,[1,2,3],(5,6,7),30)\n",
    "for x in t2: print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'range' data type\n",
    "#### > used for representing a sequence of integer values <br/> > range() is used to generate a range of integer values <br/> > slicing is applicable <br/> > indexing is applicable <br/> > Immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "range(5)\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "range(1,5)\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "range(1,10,2)\n",
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "r=range(5) # sequence of values from 0 to 4\n",
    "print(type(r))\n",
    "print('range(5)')\n",
    "for x in r: print(x)\n",
    "r=range(1,5) # sequence of values from 1 to 4\n",
    "print('range(1,5)')\n",
    "for x in r: print(x)\n",
    "# r[0]=100  error: as range is immutable\n",
    "r=range(1,10,2) # values from 1 to 9 with a jump step of 2\n",
    "print('range(1,10,2)')\n",
    "for x in r: print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'set' data type\n",
    "#### > dynamic collection <br/> > heterogenous <br/> > mutable <br/> > unordered <br/> > no duplicates <br/> > indexing not allowed as its unordered <br/> > slicing not allowed as its unordered <br/>> symbol : {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "<class 'set'>\n",
      "{1, 2, 3}\n",
      "{1, 2, 3, (6, 7), 'ABC'}\n",
      "{1, 2, 3, 999}\n",
      "{1, 2, 3, 999, 777, 555, 333, 111, 888, 666, 444, 222}\n"
     ]
    }
   ],
   "source": [
    "s=set()\n",
    "print(type(s))\n",
    "s1={1,1,2,2,3,3}\n",
    "print(type(s1))\n",
    "print(s1)\n",
    "s2={1,2,3,(6,7),'ABC'} # list or set member objects not allowed\n",
    "print(s2)\n",
    "s1.add(999)\n",
    "print(s1)\n",
    "s1.update([111,222,333]) # adding list \n",
    "s1.update((444,555,666)) # adding tuple\n",
    "s1.update({777,888,999}) # adding set\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 'dict' data type\n",
    "#### > key-value pair <br/> > duplicate keys not stored, duplicate values are allowed <br/> > mutable <br/> > symbol: {}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{100: 'Ram', 200: 'Shyam', 300: 'Amit'}\n",
      "{100: 'Ram'}\n",
      "{100: 'Ram', 200: 'Ram'}\n",
      "{111: 'Welcome', 222: 'To', 333: 'Dictionary'}\n",
      "{111: 'Welcome', 222: 'To', 333: 'Python Dictionary'}\n"
     ]
    }
   ],
   "source": [
    "d={}\n",
    "print(type(d))\n",
    "d1={100:'Ram',200:'Shyam',300:'Amit'}\n",
    "print(d1)\n",
    "d2={100:'Ram',100:'Ram'}\n",
    "print(d2)\n",
    "d3={100:'Ram',200:'Ram'}\n",
    "print(d3)\n",
    "d[111]='Welcome'\n",
    "d[222]='To'\n",
    "d[333]='Dictionary'\n",
    "print(d)\n",
    "d[333]='Python Dictionary'\n",
    "print(d)"
   ]
  }
 ],
 "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
}