Day8_Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "869d1a32",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e96409f4",
   "metadata": {},
   "source": [
    "These dictionaries are nothing but hash tables in other programming languages.\n",
    "- Dictionaries consists of:\n",
    "\n",
    "- 1) Constructing a Dictionary\n",
    "- 2) Accessing objects from a Dictionary\n",
    "- 3) Nesting Dictionaries\n",
    "- 4) Basic Dictionary Methods\n",
    "\n",
    "- What are Mappings?\n",
    "\n",
    "- Mappings are a collection of objects that are stored by a \"key\". \n",
    "\n",
    "- Unlike a sequence, mapping store objects by their relative position.\n",
    "\n",
    "- This is an important distinction since mappings won't retain the order since they have objects defined by a key.\n",
    "\n",
    "- A Python dictionary consists of a key and then an associated value. That value can be almost any Python object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e64e110",
   "metadata": {},
   "source": [
    "## Constructing a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3ff97c74",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{True: 'value1', 'key2': 'value2', 'key1': 'abc'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a dictionary with {} and : to signify a key and a value\n",
    "my_dict = {True:'value1','key2':'value2','key1':'abc'}\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0dd8fe9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{True: 'value1', 'key2': 'value2', 'key1': 'abc'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {True:'value1','key2':'value2','key1':'valuedfvdfg','key1':'abc'} # Same key check key1 value \n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "87642935",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{True: 'value1', 'key2': 'value2', 'key1': 'zabc'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {True:'value1','key2':'value2','key1':'valuedfvdfg','key1':'zabc'} # Same key check key1 value\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d6990c04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value2'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call values by their key, accessing values based on key\n",
    "my_dict['key2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5043fb74",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'3'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Input \u001b[1;32mIn [5]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# attempting to access element which is not present in dictionary gives key-error\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mmy_dict\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m3\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[1;31mKeyError\u001b[0m: '3'"
     ]
    }
   ],
   "source": [
    "# attempting to access element which is not present in dictionary gives key-error\n",
    "my_dict['3']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d194b3a1",
   "metadata": {},
   "source": [
    "- Note:- dictionaries are very flexible in the data types they can hold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ee3356d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'key1':123,'key2':[12,23,33],'key3':['item0','item1','item2']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "10433396",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 123, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dc15f3fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's call items from the dictionary\n",
    "my_dict['key2'][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "03d616f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'item0'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can call an index on that value\n",
    "my_dict['key3'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c2c742f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ITEM0'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Can then even call methods on that value\n",
    "my_dict['key3'][0].upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d634ee98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['key1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "36f3ecb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subtract 123 from the value\n",
    "my_dict['key1'] = my_dict['key1'] - 123"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c25896d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Check\n",
    "my_dict['key1']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "286d6585",
   "metadata": {},
   "source": [
    "- Note, Python has a built-in method of doing a self subtraction or addition (or multiplication or division). \n",
    "- We could also use += or -= for the above statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9775d650",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a new dictionary\n",
    "d = {}\n",
    "type(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8847c9c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'animal': 'xyz'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a new key through assignment\n",
    "d['animal'] = 'xyz'\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c766a41c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can do this with any object\n",
    "d['answer'] = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c083f29a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'animal': 'xyz', 'answer': 42}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Show\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aa60541",
   "metadata": {},
   "source": [
    "## Nesting with Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fcb56c2",
   "metadata": {},
   "source": [
    "- Let us understand how flexible Python is with nesting objects and calling methods on them. \n",
    "- let us have a look at the dictionary nested inside a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fd7e2a66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': {'nestkey': {'subnestkey': 'value'}}}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionary nested inside a dictionary nested in side a dictionary\n",
    "d = {'key1':{'nestkey':{'subnestkey':'value'}}}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d11442ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'subnestkey': 'value'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Thats the inception of dictionaries. Now, Let's see how we can grab that value.\n",
    "# Keep calling the keys\n",
    "d['key1']['nestkey']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4772ffca",
   "metadata": {},
   "source": [
    "## Dictionary Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b96458e8",
   "metadata": {},
   "source": [
    "- There are a few methods we can call on a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8c3f888f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1, 'key2': 2, 'key3': 3}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a typical dictionary\n",
    "d = {'key1':1,'key2':2,'key3':3}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3eca5b58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 4, 'key2': 5, 'key3': 3}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Updating dictionary\n",
    "d[\"key1\"] = 4\n",
    "d[\"key2\"] = 5\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b726819d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete dictionary\n",
    "del d[\"key1\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bfaedd7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key2': 5, 'key3': 3}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2fbc6b08",
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove all elements in a dictionary\n",
    "d.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e19c0c71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6d87d372",
   "metadata": {},
   "outputs": [],
   "source": [
    "del d # delte entire dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4ceba7dd",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'd' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [27]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43md\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined"
     ]
    }
   ],
   "source": [
    "d # Not exists now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3e15a87b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Sunil', 1: 4, (1, 2): 'Hello'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strings, numbers or tuples as a key of dictionary is allowed but ['k'] as a key not allowed\n",
    "d = {}\n",
    "d[\"name\"] = \"Sunil\"\n",
    "d[1] = 4\n",
    "d[(1,2)] = \"Hello\"\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e2541d85",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [29]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m d[[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhello\u001b[39m\u001b[38;5;124m\"\u001b[39m]] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhi\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;66;03m# Not allowed\u001b[39;00m\n\u001b[0;32m      2\u001b[0m d\n",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "d[[\"hello\"]] = \"hi\" # Not allowed\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6fd40afa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Length of a dictionary\n",
    "len(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a14481c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"{'name': 'Sunil', 1: 4, (1, 2): 'Hello'}\", str)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can convert dictionary as a string representation\n",
    "str(d), type(str(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "679aa776",
   "metadata": {},
   "outputs": [],
   "source": [
    "d.clear() # Clear all from dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6c7af6d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "16a0f9a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Sunil', 1: 'one', 2: 'two'}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Copy of the dictionary\n",
    "d = {'name':'Sunil',1: \"one\",2: \"two\"}\n",
    "\n",
    "d_copy = d.copy()\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6ce7d5a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Sunil', 1: 'one', 2: 'two'}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6ac1d88d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2099465905472, 2099494926848)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(d), id(d_copy) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b3f48489",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create dictionary from key-value using fromkeys methods\n",
    "keys = ('name','school','weather')\n",
    "values = \"good\"\n",
    "\n",
    "d = d.fromkeys(keys,values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "74928494",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'good', 'school': 'good', 'weather': 'good'}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c09ab91b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SUNIL'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using get() to get a value of a key\n",
    "d = {\"fname\": \"SUNIL\", \"Lname\": \"ZAMBARE\"}\n",
    "d.get(\"fname\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "94e0ba4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "d.get(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c462117a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('fname', 'SUNIL'), ('Lname', 'ZAMBARE')])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.items() # List of key-value pair in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "328a5beb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['fname', 'Lname'])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys() # List of keys present in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "f8bf0c28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fname': 'SUNIL', 'Lname': 'ZAMBARE', 'Age': None, 'Address': None}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another method similar to get() is setDefault() but it will set the value default if key is not present for ex:-\n",
    "d.setdefault(\"Age\", None) # Age is not present so value none\n",
    "d.setdefault(\"Address\", None) # Course is preset so value will not change to None\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1daaa420",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1: 'one', 2: 'two'}, {3: 'three', 4: 'four'})"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can update dictionary using update()\n",
    "d1 = {1:\"one\",2:\"two\"}\n",
    "d2 = {3:\"three\",4:\"four\"}\n",
    "d1, d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b738a8fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'one', 2: 'two', 3: 'three', 4: 'four'}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1.update(d2)\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a1a9a03a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: 'three', 4: 'four'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "6dab3321",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['SUNIL', 'ZAMBARE', None, None])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Method to grab all values\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89276ac3",
   "metadata": {},
   "source": [
    "## Dictionary Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eea9f06",
   "metadata": {},
   "source": [
    "- like List Comprehensions, Dictionary Data Types also support their own version of comprehension for quick creation. \n",
    "- It is not as commonly used as List Comprehensions, but the syntax is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "245e4e86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{x : x**2 for x in range(10)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8ebd28f",
   "metadata": {},
   "source": [
    "## Iterating through dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5cb9d0af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key : Name  Value : Sunil\n",
      "Key : Surname  Value : Zambare\n",
      "Key : Age  Value : 38\n",
      "Key : Hometown  Value : Dongarsoni\n"
     ]
    }
   ],
   "source": [
    "mydict = {'Name': 'Sunil', 'Surname': 'Zambare', 'Age': 38, 'Hometown':'Dongarsoni'}\n",
    "for i in mydict:\n",
    "    print(f\"Key : {i}  Value : {mydict[i]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "e7b3a3f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_code = {\n",
    "    \"India\": \"IN\",\n",
    "    \"Canada\": \"CA\",\n",
    "    \"Chile\": \"CL\",\n",
    "    \"Fiji\": \"FJ\",\n",
    "    \"United states\": \"US\"\n",
    "}\n",
    "\n",
    "# Check key exists\n",
    "\"India\" in country_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "39017bb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of  India  is greater than three.\n",
      "length of  Canada  is greater than three.\n",
      "length of  Chile  is greater than three.\n",
      "length of Fiji is less than six but greater than three.\n",
      "length of  United states  is greater than three.\n"
     ]
    }
   ],
   "source": [
    "for countries in country_code:\n",
    "    if len(countries) > 4:\n",
    "        print(f\"length of  {countries}  is greater than three.\" )\n",
    "    elif (len(countries) >= 4 and len(countries) < 6):\n",
    "        print(f\"length of {countries} is less than six but greater than three.\" )\n",
    "    else:\n",
    "        print(f\"length of {countries} is less than three.\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "78a98beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find max value in nested dictionary\n",
    "dict_1 = {'Bus Station': { 'a': 15, \n",
    "                       'b': 10, \n",
    "                       'c': 2,}, \n",
    "           'Stops': {'d': 12, \n",
    "                      'e': 20,\n",
    "                      'f': 10,}} \n",
    "# Max Value in Nested Dictionary \n",
    "# Using for loop \n",
    "result = {} \n",
    "for key, val in dict_1.items(): \n",
    "    max_val = 0\n",
    "    for ele in val.values(): \n",
    "        if ele > max_val: \n",
    "            max_val = ele \n",
    "    result[key] = max_val "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "8ff901c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Bus Station': 15, 'Stops': 20}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "0bd50ba1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n",
      "2000\n",
      "2 year\n",
      "python\n",
      "2000\n",
      "2 year\n"
     ]
    }
   ],
   "source": [
    "#Create Dictionary              \n",
    "d = {'name':'python','fees':'2000','duration':'2 year'}   # d(dictionary) is Key   and   { } is value\n",
    "\n",
    "#Access elements from a dictionary\n",
    "n = d['name']\n",
    "print(n)\n",
    "\n",
    "n = d['fees']\n",
    "print(n)\n",
    "\n",
    "n = d['duration']\n",
    "print(n)\n",
    "\n",
    "#Iterating through Dictionary\n",
    "for n in d:\n",
    "    print(d[n])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "0d1955c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sunil\n"
     ]
    }
   ],
   "source": [
    "#Create a dictionary take keys as name,height and age \n",
    "d= {'name':'sunil', 'height':5.5, 'age':'38 year'}\n",
    "\n",
    "c = d.get('name')       #d.get( )...return both keys or  values \n",
    "\n",
    "#c1=d['name']\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "79dc9b77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name\n",
      "height\n",
      "age\n"
     ]
    }
   ],
   "source": [
    "for n in d.keys():    #d.keys( )...return keys\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "88977930",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sunil\n",
      "5.5\n",
      "38 year\n"
     ]
    }
   ],
   "source": [
    "for n in d.values():  #d.values( )...return values\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "afb22d97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name sunil\n",
      "height 5.5\n",
      "age 38 year\n"
     ]
    }
   ],
   "source": [
    "for a,b in d.items():   #d.items( )...return both keys and values\n",
    "    print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d761bacc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'sunil', 'height': 5.5}\n"
     ]
    }
   ],
   "source": [
    "#Delete Function\n",
    "\n",
    "del d['age']         #del d[ ]..delete the both keys or values \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "29eae4c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'height': 5.5}\n"
     ]
    }
   ],
   "source": [
    "d.pop('name')         #d.po.[ ]...delete function\n",
    "#print(d.pop('name'))\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "2ed03120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'sunil', 'height': 5.7}\n"
     ]
    }
   ],
   "source": [
    "d = dict(name='sunil', height=5.7) #for creating dictionary\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "3e9098e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'student':'rahul', 'fees':'40000', 'duration':'3 year'}  #Updating Dictinary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "de13e75c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'student': 'santosh', 'fees': '40000', 'duration': '3 year'}\n"
     ]
    }
   ],
   "source": [
    "d.update({'student':'santosh'})\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "b7bcff37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "d.clear()           #delete all data of dictionary ...return[ ]\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "426c9afa",
   "metadata": {},
   "source": [
    "## NESTED DICTIONARY(Putting dictionary inside another dictionary)..it is a collection of dictionaries into one single dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "449367b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a Nested Dictionary...\n",
    "\n",
    "course = {'phd' : {'duration':'3 Year', 'fees':100000},\n",
    "          'c++' : {'duration':'4 month', 'fees':12000},\n",
    "       'python' : {'duration':'5 month', 'fees':1500},\n",
    "      }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "a18159e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'phd': {'duration': '3 Year', 'fees': 100000}, 'c++': {'duration': '4 month', 'fees': 12000}, 'python': {'duration': '5 month', 'fees': 1500}}\n",
      "The updated fee structure of c++ : 20000\n"
     ]
    }
   ],
   "source": [
    "print(course)\n",
    "course['c++']['fees'] = 20000  #for updating value\n",
    "print(f\"The updated fee structure of c++ : {course['c++']['fees']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "c2f02056",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'duration': '3 Year', 'fees': 100000}\n",
      "{'duration': '4 month', 'fees': 20000}\n",
      "{'duration': '5 month', 'fees': 1500}\n"
     ]
    }
   ],
   "source": [
    "print(course['phd'])\n",
    "print(course['c++'])\n",
    "print(course['python'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "0b6d2649",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "phd {'duration': '3 Year', 'fees': 100000}\n",
      "c++ {'duration': '4 month', 'fees': 20000}\n",
      "python {'duration': '5 month', 'fees': 1500}\n"
     ]
    }
   ],
   "source": [
    "for k,v in course.items():\n",
    "    print(k,v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b052fbe3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000\n"
     ]
    }
   ],
   "source": [
    "print(course['phd']['fees'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "0f28627c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "phd 3 Year 100000\n",
      "c++ 4 month 20000\n",
      "python 5 month 1500\n"
     ]
    }
   ],
   "source": [
    "for k,v in course.items():  \n",
    "    print(k,v[ 'duration'],v[ 'fees'])"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}