9. Python Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f05f587b",
   "metadata": {},
   "source": [
    "# Python Dictionary\n",
    "- Dictionaries are used to store data values in key:value pairs.\n",
    "- A dictionary is a collection which is ordered*, mutable(changeable) and do not allow duplicates\n",
    "- As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered\n",
    "- Dictionaries are written with curly brackets, and have keys and values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38382c9d",
   "metadata": {},
   "source": [
    "# 1.Python Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff4408f",
   "metadata": {},
   "source": [
    "## a. Creating empty dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a767a7fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "dict1 = dict()\n",
    "print(dict1)\n",
    "print(type(dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ff8083",
   "metadata": {},
   "source": [
    "## b. Creating dictionary with elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "99368847",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "    \"brand\": \"Ford\",\n",
    "    \"model\": \"Mustang\",\n",
    "    \"year\": 1964\n",
    "        }\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c5a81c6",
   "metadata": {},
   "source": [
    "## c. Duplicates Not Allowed\n",
    "- Dictionaries cannot have two items with the same key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "71cd8977",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "    \"brand\": \"Ford\",\n",
    "    \"model\": \"Mustang\",\n",
    "    \"year\": 1964,\n",
    "    \"year\":2020 #year value of 1964 is overridden by 2020\n",
    "}\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d3a9c3b",
   "metadata": {},
   "source": [
    "## d. Dictionary Length\n",
    "- To determine how many items a dictionary has, use the len() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eeac1571",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(len(dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41f38a05",
   "metadata": {},
   "source": [
    "## e. Dictionary Items - Data Types\n",
    "- The values in dictionary items can be of any data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a5a89690",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue', 'red']}\n"
     ]
    }
   ],
   "source": [
    "#String, int, boolean, and list data types:\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\",\"red\"]\n",
    "}\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a98cd21",
   "metadata": {},
   "source": [
    "# 2. Access Items"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e63aeba8",
   "metadata": {},
   "source": [
    "## a. Accessing Items\n",
    "- You can access the items of a dictionary by referring to its key name, inside square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "da8e6797",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mustang\n"
     ]
    }
   ],
   "source": [
    "#Get the value of the \"model\" key\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "x = dict1[\"model\"]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6777b6b",
   "metadata": {},
   "source": [
    "<b>There is also a method called get() that will give you the same result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "23cd2acb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mustang'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1.get(\"model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9df5ce4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.get(\"speed\") #Key is not available hence no output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a6c79474",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1.get(\"speed\",100) #if Key is not available return default 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c17eab14",
   "metadata": {},
   "source": [
    "## b. Get Keys\n",
    "- The keys() method will return a list of all the keys in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b2805d44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['brand', 'model', 'year'])\n"
     ]
    }
   ],
   "source": [
    "x= dict1.keys()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "80e6cda8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['brand', 'model', 'year'])\n",
      "dict_keys(['brand', 'model', 'year', 'color'])\n"
     ]
    }
   ],
   "source": [
    "#Add a new item to the original dictionary, and see that the keys list gets updated as well\n",
    "\n",
    "car = {\n",
    "\"brand\": \"Ford\",\n",
    "\"model\": \"Mustang\",\n",
    "\"year\": 1964\n",
    "}\n",
    "\n",
    "x = car.keys()\n",
    "\n",
    "print(x) #before the change\n",
    "\n",
    "car[\"color\"] = \"white\"\n",
    "\n",
    "print(x) #after the change"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b436364a",
   "metadata": {},
   "source": [
    "## c. Get Values\n",
    "- The values() method will return a list of all the values in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5aca465d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['Ford', 'Mustang', 1964])\n"
     ]
    }
   ],
   "source": [
    "x = dict1.values()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cf334056",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Values in Dictionary :  dict_values(['Ford', 'Mustang', 1964])\n",
      "Updated Values in Dictionary :  dict_values(['Ford', 'Mustang', 2020])\n"
     ]
    }
   ],
   "source": [
    "#Make a change in the original dictionary, and see that the values list gets updated as well\n",
    "\n",
    "car = {\n",
    "\"brand\": \"Ford\",\n",
    "\"model\": \"Mustang\",\n",
    "\"year\": 1964\n",
    "}\n",
    "\n",
    "x = car.values()\n",
    "\n",
    "print(\"Original Values in Dictionary : \", x) #before the change\n",
    "\n",
    "car[\"year\"] = 2020\n",
    "\n",
    "print(\"Updated Values in Dictionary : \", x) #after the change"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac7e834c",
   "metadata": {},
   "source": [
    "## d. Get Items\n",
    "- The items() method will return each item in a dictionary, as tuples in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4251e9a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])\n"
     ]
    }
   ],
   "source": [
    "x = dict1.items()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "aee63d26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])\n",
      "Updated Dictionary :  dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020), ('color', 'red')])\n"
     ]
    }
   ],
   "source": [
    "#Make a change in the original dictionary, and see that the items list gets updated as well\n",
    "\n",
    "car = {\n",
    "\"brand\": \"Ford\",\n",
    "\"model\": \"Mustang\",\n",
    "\"year\": 1964\n",
    "}\n",
    "\n",
    "x = car.items()\n",
    "\n",
    "print(\"Original Dictionary : \",x) #before the change\n",
    "\n",
    "car[\"year\"] = 2020 #changing the value of the key year\n",
    "car[\"color\"] = \"red\" #Adding the new key value pair\n",
    "\n",
    "\n",
    "print(\"Updated Dictionary : \", x) #after the change"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f0c72d7",
   "metadata": {},
   "source": [
    "## e. Check if Key Exists\n",
    "- To determine if a specified key is present in a dictionary use the in keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4690190b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, 'model' is one of the keys in the thisdict dictionary\n"
     ]
    }
   ],
   "source": [
    "#Check if \"model\" is present in the dictionary\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "if \"model\" in dict1:\n",
    "  print(\"Yes, 'model' is one of the keys in the thisdict dictionary\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4af2054f",
   "metadata": {},
   "source": [
    "# 3. Change Dictionary Items"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "985a803d",
   "metadata": {},
   "source": [
    "## a. Change Values\n",
    "- You can change the value of a specific item by referring to its key name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f4327bf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Updated Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 2018}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "dict1[\"year\"] = 2018\n",
    "print(\"Updated Dictionary : \",dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66d7f1b6",
   "metadata": {},
   "source": [
    "## b.Update Dictionary\n",
    "- The update() method will update the dictionary with the items from the given argument.\n",
    "\n",
    "- The argument must be a dictionary, or an iterable object with key:value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8c066a36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Updated Dictionary using update() - changing existing element :  {'brand': 'Ford', 'model': 'Mustang', 'year': 2020}\n"
     ]
    }
   ],
   "source": [
    "#Update the \"year\" of the car by using the update() method:\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "dict1.update({\"year\": 2020})\n",
    "print(\"Updated Dictionary using update() - changing existing element : \",dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c4504f0",
   "metadata": {},
   "source": [
    "# 4. Add Dictionary Items"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc9d85d2",
   "metadata": {},
   "source": [
    "## a. Adding Items\n",
    "- Adding an item to the dictionary is done by using a new index key and assigning a value to it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ec6d5c45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Updated Dictionary after adding new element :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "dict1[\"color\"] = \"red\" #adding new element\n",
    "print(\"Updated Dictionary after adding new element : \",dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b02affb",
   "metadata": {},
   "source": [
    "## b. Update Dictionary\n",
    "- The update() method will update the dictionary with the items from a given argument. If the item does not exist, the item will be added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "da45eed0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Updated Dictionary using update() - adding new element :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'}\n"
     ]
    }
   ],
   "source": [
    "#Add a color item to the dictionary by using the update() method\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "dict1.update({\"color\": \"red\"})\n",
    "print(\"Updated Dictionary using update() - adding new element : \",dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f174389",
   "metadata": {},
   "source": [
    "# 5. Remove Dictionary Items"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ede2935",
   "metadata": {},
   "source": [
    "# a. Removing Items\n",
    "- There are several methods to remove items from a dictionary\n",
    "    - pop() Method\n",
    "    - popitem() Method\n",
    "    - del keyword\n",
    "    - clear() method\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c17c1a82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Pop method remove the item from dictionary and returns the value for that key :  Mustang\n",
      "Updated Dictionary - after using pop() :  {'brand': 'Ford', 'year': 1964}\n"
     ]
    }
   ],
   "source": [
    "#The pop() method removes the item with the specified key name\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "\n",
    "x = dict1.pop(\"model\") #popping the element\n",
    "\n",
    "print(\"Pop method remove the item from dictionary and returns the value for that key : \",x)\n",
    "print(\"Updated Dictionary - after using pop() : \",dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d2a37bd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Popitem method removed the item from dictionary and returns the key-value pair :  ('year', 1964)\n",
      "Updated Dictionary - after using popitem() :  {'brand': 'Ford', 'model': 'Mustang'}\n"
     ]
    }
   ],
   "source": [
    "#The popitem() method removes the last inserted item (in versions before 3.7, a random item is removed instead)\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "\n",
    "x = dict1.popitem() #popping the last element\n",
    "\n",
    "print(\"Popitem method removed the item from dictionary and returns the key-value pair : \",x)\n",
    "print(\"Updated Dictionary - after using popitem() : \",dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4495b166",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Updated Dictionary - after using del :  {'brand': 'Ford', 'year': 1964}\n"
     ]
    }
   ],
   "source": [
    "#The del keyword removes the item with the specified key name\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "\n",
    "del dict1['model'] #deleting the specified element\n",
    "\n",
    "print(\"Updated Dictionary - after using del : \",dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d5872c0c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "we have deleted complete dictionary hence, dict1 doesnot exist now and result in error: \n",
      "\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'dict1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-31c924c07d65>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"we have deleted complete dictionary hence, dict1 doesnot exist now and result in error: \\n\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdict1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'dict1' is not defined"
     ]
    }
   ],
   "source": [
    "#The del keyword can also delete the dictionary completely\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "\n",
    "del dict1 #deleting the complete dictionary\n",
    "\n",
    "print(\"we have deleted complete dictionary hence, dict1 doesnot exist now and result in error: \\n\")\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c5a68885",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Updated Dictionary - after using clear() :  {}\n"
     ]
    }
   ],
   "source": [
    "#The clear() method empties the dictionary\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary : \",dict1)\n",
    "\n",
    "dict1.clear() #empties the dictionary but doesnot delete the dictionary\n",
    "\n",
    "print(\"Updated Dictionary - after using clear() : \",dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64be1c36",
   "metadata": {},
   "source": [
    "# 6. Copy Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb5f90cc",
   "metadata": {},
   "source": [
    "## a. Copy a Dictionary\n",
    "- You cannot copy a dictionary simply by typing dict2 = dict1, because: dict2 will only be a reference to dict1, and changes made in dict1 will automatically also be made in dict2.\n",
    "\n",
    "- There are ways to make a copy, one way is to use the built-in Dictionary method copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "efd784df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary dict1 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Copied Dictionary dict2 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n"
     ]
    }
   ],
   "source": [
    "#Make a copy of a dictionary with the copy() method\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary dict1 : \",dict1)\n",
    "dict2 = dict1.copy() #Making a copy using copy function\n",
    "print(\"Copied Dictionary dict2 : \",dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b76a53b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We made changes in year in dictionary 2\n",
      "Dict1 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Dict2 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 2020}\n",
      "No impact on dictionary-1\n"
     ]
    }
   ],
   "source": [
    "#Making changes in dict2 doesnot impact on dict1\n",
    "dict2['year'] =2020\n",
    "print(\"We made changes in year in dictionary 2\")\n",
    "print(\"Dict1 : \",dict1)\n",
    "print(\"Dict2 : \",dict2)\n",
    "print(\"No impact on dictionary-1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e0fe155c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Dictionary dict1 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Copied Dictionary dict2 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n"
     ]
    }
   ],
   "source": [
    "#Make a copy of a dictionary with the dict() function:\n",
    "\n",
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(\"Original Dictionary dict1 : \",dict1)\n",
    "dict2 = dict(dict1) #Making a copy using dict function\n",
    "print(\"Copied Dictionary dict2 : \",dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "37f674d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We made changes in year in dictionary 2\n",
      "Dict1 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}\n",
      "Dict2 :  {'brand': 'Ford', 'model': 'Mustang', 'year': 2020}\n",
      "No impact on dictionary-1\n"
     ]
    }
   ],
   "source": [
    "#Making changes in dict2 doesnot impact on dict1\n",
    "dict2['year'] =2020\n",
    "print(\"We made changes in year in dictionary 2\")\n",
    "print(\"Dict1 : \",dict1)\n",
    "print(\"Dict2 : \",dict2)\n",
    "print(\"No impact on dictionary-1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27e60249",
   "metadata": {},
   "source": [
    "# 7. Nested Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33264b63",
   "metadata": {},
   "source": [
    "## a. Nested Dictionaries\n",
    "- A dictionary can contain dictionaries, this is called nested dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "baefbfc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'child1': {'name': 'Anit', 'year': 2004}, 'child2': {'name': 'Trishaan', 'year': 2007}, 'child3': {'name': 'Tina', 'year': 2011}}\n"
     ]
    }
   ],
   "source": [
    "#Create a dictionary that contain three dictionaries:\n",
    "\n",
    "myfamily = {   \"child1\" : { \"name\" : \"Anit\", \"year\" : 2004},\n",
    "            \n",
    "               \"child2\" : { \"name\" : \"Trishaan\", \"year\" : 2007},\n",
    "               \n",
    "               \"child3\" : { \"name\" : \"Tina\", \"year\" : 2011}\n",
    "            }\n",
    "\n",
    "print(myfamily)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "81cc6534",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Details of child-1 :  {'name': 'Anit', 'year': 2004}\n",
      "Details of child-2 :  {'name': 'Trishaan', 'year': 2007}\n",
      "Details of child-3 :  {'name': 'Tina', 'year': 2011}\n"
     ]
    }
   ],
   "source": [
    "#Extracting the information in dictionary\n",
    "print(\"Details of child-1 : \",myfamily['child1'])\n",
    "print(\"Details of child-2 : \",myfamily['child2'])\n",
    "print(\"Details of child-3 : \",myfamily['child3'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "25d702f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'child1': {'name': 'Anit', 'year': 2004}, 'child2': {'name': 'Trishaan', 'year': 2007}, 'child3': {'name': 'Tina', 'year': 2011}}\n"
     ]
    }
   ],
   "source": [
    "#Create three dictionaries, then create one dictionary that will contain the other three dictionaries:\n",
    "\n",
    "child1 = {\"name\" : \"Anit\",  \"year\" : 2004}\n",
    "\n",
    "child2 = {\"name\" : \"Trishaan\",\"year\" : 2007}\n",
    "\n",
    "child3 = {\"name\" : \"Tina\", \"year\" : 2011}\n",
    "\n",
    "myfamily = { \"child1\" : child1,\n",
    "             \"child2\" : child2,\n",
    "             \"child3\" : child3\n",
    "            }\n",
    "\n",
    "print(myfamily)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "308e09bb",
   "metadata": {},
   "source": [
    "# 8. Dictionary Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbcea726",
   "metadata": {},
   "source": [
    "## a. fromkeys()\t\n",
    "- Returns a dictionary with the specified keys and value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "473e6e76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 0, 'key2': 0, 'key3': 0}\n"
     ]
    }
   ],
   "source": [
    "#Create a dictionary with 3 keys, all with the value 0\n",
    "\n",
    "x = ('key1', 'key2', 'key3')\n",
    "y = 0\n",
    "\n",
    "dict1 = dict.fromkeys(x, y)\n",
    "\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b32928e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': None, 'key2': None, 'key3': None}\n"
     ]
    }
   ],
   "source": [
    "x = ('key1', 'key2', 'key3')\n",
    "\n",
    "dict1 = dict.fromkeys(x)\n",
    "\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce2e618",
   "metadata": {},
   "source": [
    "## b. setdefault()\t\n",
    "- Returns the value of the specified key. If the key does not exist: insert the key, with the specified value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ab4a515d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Owner'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "car.get(\"Parmeet\",\"Owner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b83af09e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Owner'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car.setdefault(\"Parmeet\",\"Owner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2683a6ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mustang\n"
     ]
    }
   ],
   "source": [
    "#Get the value of the \"model\" item\n",
    "\n",
    "car = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "\n",
    "x = car.setdefault(\"model\", \"Bronco\") #model already exist in dictionary hence fetching value from dictionary\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d6264c93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "white\n"
     ]
    }
   ],
   "source": [
    "#Get the value of the \"color\" item, if the \"color\" item does not exist, insert \"color\" with the value \"white\"\n",
    "\n",
    "car = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "\n",
    "x = car.setdefault(\"color\", \"white\") #color is not present in ditionary hence giving white as value for dictionary\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "245c39d9",
   "metadata": {},
   "source": [
    "## 9. Compare between setdefault and get"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "eb476e15",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3f48fdd1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'owner'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Get function\n",
    "car.get(\"parmeet\",\"owner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ea04e765",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#No impact on the dictionary once we used get function in above cell\n",
    "car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ba37f352",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'owner'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#SetDefault function\n",
    "car.setdefault(\"parmeet\",\"owner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "2601a935",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'parmeet': 'owner'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Dictionary is updated with default value once we used setdefault in above cell\n",
    "car"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b98b3f7d",
   "metadata": {},
   "source": [
    "- get function will only return the default value and there will be no impact on the dictionary\n",
    "- setdefault function will also return the default value but that default value will be udated in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3e0da93",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}