2. List_Tuple_Set_Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PRACTICAL-2: Introduction to Dictionary, Tuple, Set\n",
    "By 20CE155 ADNAN VAHORA, CE-2(C2)\n",
    "\n",
    "Link: https://github.com/settler-av/CE259-PIP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# __1. Dictionary__\n",
    "Dictionaries are used to store data values in key:value pairs.\n",
    "\n",
    "A dictionary is a collection which is ordered*, changeable and do not allow duplicates.\n",
    "\n",
    "_*(As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered.)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1:\n",
    "<p> Write a Python script to check whether a given key already exists in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a key: key5\n",
      "key does not exist\n"
     ]
    }
   ],
   "source": [
    "#create test dictionary\n",
    "test_dict = {'key1': 1, 'key2': 2, 'key3': 3}\n",
    "#check if key inserted by user exists or not\n",
    "print(\"key exists\") if test_dict.get(input('Enter a key: ')) else print(\"key does not exist\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 2:\n",
    "Write a Python script to merge two Python dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merging two dictionaries:\n",
      "Dictionary 3:  {'a': 100, 'b': 200, 'x': 300, 'y': 200}\n",
      "Dictionary 4:  {'a': 100, 'b': 200, 'x': 300, 'y': 200}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'a': 100, 'b': 200}\n",
    "dict2 = {'x': 300, 'y': 200}\n",
    "#METHOD 1\n",
    "# ** implies that an argument is a dictionary.\n",
    "print(\"Merging two dictionaries:\")\n",
    "dict3 = {**dict1, **dict2}\n",
    "print(\"Dictionary 3: \", dict3)\n",
    "#METHOD 2\n",
    "# Using | in Python 3.9\n",
    "dict4 = dict1 | dict2\n",
    "print(\"Dictionary 4: \", dict4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 3:\n",
    "Write a Python program to sum all the items in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "600\n"
     ]
    }
   ],
   "source": [
    "dict = {'a': 100, 'b': 200, 'c': 300}\n",
    "#dict.values() returns a list of values\n",
    "#sum() returns the sum of all the values in the list\n",
    "print(sum(dict.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 4:\n",
    "Write a Python script to add a key to a dictionary.\n",
    "\n",
    "    Sample Dictionary : {0: 10, 1: 20}\n",
    "    Expected Result : {0: 10, 1: 20, 2: 30}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value: 30\n",
      "Enter a key: 2\n",
      "{0: 10, 1: 20, 2: 30}\n"
     ]
    }
   ],
   "source": [
    "sample = {0: 10, 1: 20}\n",
    "#adding a new key to the dictionary\n",
    "sample[int(input(\"Enter a key: \"))] = int(input(\"Enter a value: \"))\n",
    "print(sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 5:\n",
    "\n",
    "Write a Python script to concatenate the following dictionaries to create a new one.\n",
    "\n",
    "    Sample Dictionary : dic1={1:10, 2:20} dic2={3:30, 4:40} dic3={5:50,6:60}\n",
    "    Expected Result : {1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60}\n"
     ]
    }
   ],
   "source": [
    "dic1={1:10, 2:20}\n",
    "dic2={3:30, 4:40}\n",
    "dic3={5:50,6:60}\n",
    "#concatenating the dictionaries (using feature of python 3.9)\n",
    "dict4 = dic1 | dic2 | dic3\n",
    "print(dict4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Tuple\n",
    "Tuples are used to store multiple items in a single variable.\n",
    "\n",
    "A tuple is a collection which is ordered and unchangeable.\n",
    "\n",
    "Tuples are written with round brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1:\n",
    "Write a Python program to create a tuple with different data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of element in int_tuples:  <class 'int'>\n",
      "type of element in float_tuples:  <class 'float'>\n",
      "type of element in string_tuples:  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "int_tuples = (1, 2, 3, 4, 5)\n",
    "print(\"type of element in int_tuples: \", type(int_tuples[1]))\n",
    "float_tuples = (1.1, 2.2, 3.3, 4.4, 5.5)\n",
    "print(\"type of element in float_tuples: \", type(float_tuples[1]))\n",
    "string_tuples = (\"a\", \"b\", \"c\", \"d\", \"e\")\n",
    "print(\"type of element in string_tuples: \", type(string_tuples[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 2:\n",
    "Write a Python program to create a tuple with numbers and print one item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "my_tuple = (1,2,3,4,5,6,7,8,9,10)\n",
    "#get a random number from the tuple\n",
    "print(my_tuple[randint(0, len(my_tuple)-1)])\n",
    "#output is subjected to change every time the program is executed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 3:\n",
    "Write a Python program to add an item in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original tuple: (1, 2, 3, 4, 5)\n",
      "Enter a number to add in tuple: 10\n",
      "after updating: (1, 2, 3, 4, 5, 10)\n"
     ]
    }
   ],
   "source": [
    "first_tuple = (1, 2, 3, 4, 5)\n",
    "print(\"Original tuple: \" + str(first_tuple))\n",
    "#adding item in tuple: since tuple are immutable, we have to create a new tuple that contains desired item and first tuple\n",
    "second_tuple = first_tuple + (int(input(\"Enter a number to add in tuple: \")),)\n",
    "print(\"after updating: \" + str(second_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 4:\n",
    "Write a Python program to convert a tuple to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of string tuple is of type <class 'str'>\n",
      "Tuple: (1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489, 10000000000)\n"
     ]
    }
   ],
   "source": [
    "#create random tuple\n",
    "my_tuple = tuple(i**i for i in range(1,11))\n",
    "#convert tuple to string\n",
    "string_tuple = str(my_tuple)\n",
    "print(\"Type of string tuple is of type \" + str(type(string_tuple)))\n",
    "print(\"Tuple: \" + str(my_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 5:\n",
    "Write a Python program to find the length of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuple: (2, 1, 5, 5, 1, 1, 1, 1, 2, 1, 11, 3, 2, 2, 8, 8, 3, 4, 14, 7, 1, 2, 1, 2, 1, 3, 1, 2, 1, 1, 1, 13, 177, 1, 1, 1, 1, 1, 1, 2, 1, 2, 31, 1, 1, 2, 2, 7, 1, 6)\n",
      "Length of tuple: 50\n"
     ]
    }
   ],
   "source": [
    "#create tuple with random numbers\n",
    "rand_tuple = tuple(i//(i - randint(0, i-1)) for i in range(500,550))\n",
    "print(\"Tuple: \" + str(rand_tuple))\n",
    "print(\"Length of tuple: \" + str(len(rand_tuple)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Set\n",
    "Sets are used to store data values in unordered collection.\n",
    "A set is a collection which is **unordered** and **unindexed**. In Python sets are written with curly brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1:\n",
    "Write a Python program to add member(s) in a set and clear a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original set: {1, 2, 3, 4, 5}\n",
      "after adding 6, 7, 3 in set1: {1, 2, 3, 4, 5, 6, 7}\n",
      "after removing 2 from set1: {1, 3, 4, 5, 6, 7}\n",
      "After clearing the set  set()\n"
     ]
    }
   ],
   "source": [
    "set1 = {1,2,3,4,5}\n",
    "print(\"The original set: \" + str(set1))\n",
    "#use add function to add a new member in the set\n",
    "set1.add(6)\n",
    "set1.add(7)\n",
    "set1.add(3) #set will not allow duplicates\n",
    "print(\"after adding 6, 7, 3 in set1:\",set1)\n",
    "#use remove function to remove a member in the set\n",
    "set1.remove(2)\n",
    "print(\"after removing 2 from set1:\",set1)\n",
    "#use clear function to clear the set\n",
    "set1.clear()\n",
    "print(\"After clearing the set \",set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 2:\n",
    "Write a Python program to remove an item from a set if it is present in the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any number between 1 to 10: 4\n",
      "{0, 1, 2, 3, 4, 5, 6, 7, 9, 10}\n",
      "The number is removed from the set\n",
      "Updated set is: {0, 1, 2, 3, 5, 6, 7, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "set2 = set(i%randint(1,11) for i in range(100,150))\n",
    "# print(set2)\n",
    "my_number = int(input(\"Enter any number between 1 to 10: \"))\n",
    "my_number %= 11\n",
    "print(set2)\n",
    "if my_number in set2:\n",
    "    set2.remove(my_number)\n",
    "    print(\"The number is removed from the set\")\n",
    "    print(\"Updated set is:\",set2)\n",
    "else:\n",
    "    print(\"The number is not in the set\")\n",
    "    print(\"The set is: \",set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 3:\n",
    "Write a Python program to create an intersection, Union, difference of sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection of A and B:  {8, 9, 5}\n",
      "Union of A and B:  {1, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "Difference of A and B:  {10, 4, 7}\n",
      "Difference of B and A:  {1, 3, 6}\n"
     ]
    }
   ],
   "source": [
    "#create a random set\n",
    "A = {4,5,7,8,9,10}\n",
    "B = {1,3,5,6,8,9}\n",
    "#intersenction of A and B\n",
    "print(\"Intersection of A and B: \",A.intersection(B))\n",
    "#union of A and B\n",
    "print(\"Union of A and B: \",A.union(B))\n",
    "#difference of A and B\n",
    "print(\"Difference of A and B: \",A.difference(B))\n",
    "#difference of B and A\n",
    "print(\"Difference of B and A: \",B.difference(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 4:\n",
    "Write a Python program to find maximum and the minimum value in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum value in the set is:  11\n",
      "The minimum value in the set is:  1\n"
     ]
    }
   ],
   "source": [
    "set4 = {1,2,5,4,3,10,11}\n",
    "print(\"The maximum value in the set is: \",max(set4))\n",
    "print(\"The minimum value in the set is: \",min(set4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 5:\n",
    "Write a Python program to find the most common elements and their counts from list, tuple, dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list is:  [4, 11, 13, 13, 10, 37, 7, 17, 0, 1, 24, 3, 4, 24, 6, 28, 8, 12, 26, 33, 8, 0, 8, 11, 4, 13, 4, 19, 41, 29, 15, 41, 0, 25, 11, 27, 16, 22, 30, 31, 11, 16, 17, 11, 0, 2, 11, 35, 12, 49, 2, 1, 8, 5, 14, 10, 2, 4, 8, 9, 7, 4, 4, 28, 0, 15, 4, 2, 3, 3, 12, 0, 14, 2, 18, 9, 20, 42, 7, 23, 9, 1, 2, 3, 13, 0, 14, 7, 30, 4, 11, 16, 17, 13, 28, 15, 18, 17, 3, 43]\n",
      "The most common element in the list is (element: frequency): [(4, 9)]\n",
      "\n",
      "The tuple is:  (10, 1, 12, 16, 36, 15, 17, 8, 8, 6, 2, 1, 4, 1, 15, 1, 2, 10, 10, 7, 12, 6, 22, 3, 0, 5, 36, 7, 16, 4, 0, 19, 0, 13, 14, 9, 24, 2, 38, 1, 0, 17, 10, 8, 10, 11, 1, 15, 12, 24, 38, 3, 8, 3, 0, 5, 0, 17, 8, 6, 4, 11, 6, 29, 24, 0, 16, 9, 8, 35, 12, 1, 2, 23, 24, 15, 0, 5, 24, 23, 16, 8, 2, 2, 4, 0, 20, 31, 38, 4, 34, 6, 36, 1, 16, 6, 7, 9, 6, 10)\n",
      "The most common element in the tuple is (element: frequency): [(0, 9)]\n",
      "\n",
      "The dictionary is:  {1: 0, 2: 1, 3: 14, 4: 3, 5: 10, 6: 4, 7: 7, 8: 6, 9: 0, 10: 1, 11: 2, 12: 3, 13: 4, 14: 10, 15: 6, 16: 1, 17: 8, 18: 5, 19: 1, 20: 4, 21: 0, 22: 9, 23: 15, 24: 3, 25: 0, 26: 1, 27: 0, 28: 2, 29: 8, 30: 3, 31: 1, 32: 5, 33: 8, 34: 7, 35: 14, 36: 13, 37: 1, 38: 0, 39: 12, 40: 7, 41: 5, 42: 15, 43: 7, 44: 8, 45: 0, 46: 5, 47: 1, 48: 0, 49: 0, 50: 5, 51: 10, 52: 1, 53: 2, 54: 13, 55: 4, 56: 10, 57: 2, 58: 1, 59: 8, 60: 6, 61: 4, 62: 5, 63: 0, 64: 9, 65: 8, 66: 5, 67: 10, 68: 3, 69: 14, 70: 1, 71: 6, 72: 7, 73: 0, 74: 11, 75: 2, 76: 10, 77: 11, 78: 0, 79: 1, 80: 0, 81: 16, 82: 1, 83: 2, 84: 1, 85: 0, 86: 5, 87: 14, 88: 16, 89: 8, 90: 10, 91: 11, 92: 5, 93: 3, 94: 13, 95: 0, 96: 7, 97: 1, 98: 8, 99: 6, 100: 3}\n",
      "The most common element in the dictionary is (element: frequency): [(0, 15)]\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "my_list = list(i%randint(1,50) for i in range(1000,1100) )\n",
    "print(\"The list is: \",my_list)\n",
    "# using Counter to find frequency of elements\n",
    "frequency = collections.Counter(my_list)\n",
    "\n",
    "#find the most common elements in the list with frequency\n",
    "print(\"The most common element in the list is (element: frequency): \"+str(frequency.most_common(1)))\n",
    "\n",
    "#find the most common elements in the tuple with frequency\n",
    "my_tuple = tuple(i%randint(1,50) for i in range(1000,1100))\n",
    "print(\"\\nThe tuple is: \",my_tuple)\n",
    "frequency = collections.Counter(my_tuple)\n",
    "print(\"The most common element in the tuple is (element: frequency): \"+str(frequency.most_common(1)))\n",
    "#find the most common elements in the dictionary with frequency\n",
    "my_dict = {i - 999:i%randint(1,20) for i in range(1000,1100) }\n",
    "print(\"\\nThe dictionary is: \",my_dict)\n",
    "frequency = collections.Counter(my_dict.values())\n",
    "print(\"The most common element in the dictionary is (element: frequency): \"+str(frequency.most_common(1)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}