Let's Learn Python/05. Python - Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Dictionary\n",
    "\n",
    "Let's dive into the world of dictionaries, a fundamental data structure in Python. We'll cover how to create, access, and manipulate key-value pairs within dictionaries.\n",
    "\n",
    "A **dictionary** in Python is an unordered collection of key-value pairs. It's a data structure that allows you to store and retrieve data using unique keys. Each key is associated with a corresponding value. \n",
    "\n",
    "We'll learn about the following topics:\n",
    "\n",
    "   - [5.1. Creating Dictionary](#Creating_Dictionary)\n",
    "   - [5.2. Built-in Dictionary Functions](#Builtin_Dictionary_Functions)\n",
    "   - [5.3. Accessing Dictionary Values](#Accessing_Dictionary_Values)\n",
    "   - [5.4. Dictionary Properties](#Dictionary_Properties)\n",
    "   - [5.5. Dictionary Operators](#Dictionary_Operators)\n",
    "   - [5.6. Built-in Dictionary Methods](#Builtin_Dictionary_Methods)\n",
    "   - [5.7. Nesting Dictionaries](#Nesting_Dictionaries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "  <img width=\"550\" height=\"300\" src=\"https://realpython.com/cdn-cgi/image/width=960,format=auto/https://files.realpython.com/media/Dictionaries-in-Python_Watermarked.3656a2293c00.jpg\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th>Name</th>\n",
    "      <th>Type in Python</th>\n",
    "      <th>Description</th>\n",
    "      <th>Example</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td>Dictionaries</td>\n",
    "      <td>dict</td>\n",
    "      <td>Unordered key:value pairs in { }.</td>\n",
    "      <td>{'key':10, 'word': 'hello'}</td>  \n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are a type of mapping. Mappings are collections of objects stored with unique keys, unlike sequences that store objects based on their relative positions. This distinction is significant because mappings do not preserve the order of objects, as they are defined by their keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type({'key':10, 'word': 'hello'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Creating_Dictionary'></a>\n",
    "\n",
    "## 5.1. Creating Dictionary:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries in Python are created using curly braces `{}`. Each key-value pair within the dictionary is separated by a colon `:`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = {'key1':'value1', 'key2':'value2', 'key3':'value3'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to note that dictionaries are very flexible in the data types they can hold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {'key1':123, 'key2':[12,23,33], 'key3':['item0','item1','item2']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note that keys in a Python dictionary can be any immutable object, including numbers, strings, tuples, and booleans. Lists cannot be used as keys because they are mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {1: \"apple\", (1, 2): \"point A\", True: \"enabled\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Builtin_Dictionary_Functions'></a>\n",
    "\n",
    "## 5.2. Built-in Dictionary Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`len()`**: Python's built-in len() function returns the number of key-value pairs in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Accessing_Dictionary_Values'></a>\n",
    "\n",
    "## 5.3. Accessing Dictionary Values:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the value associated with a specific key in a dictionary, you use square brackets `[]` and provide the key as an argument.\n",
    "\n",
    "`Name_of_Dictionary[key]`  ---> value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 123, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['item0', 'item1', 'item2']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a['key3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Can call an index on that value\n",
    "a['key2'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a['key2'][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Dictionary_Properties'></a>\n",
    "\n",
    "## 5.4. Dictionary Properties:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Unordered**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {'key1':123, 'key2':[12,23,33], 'key3':['item0','item1','item2']}\n",
    "\n",
    "b = {'key2':[12,23,33], 'key3':['item0','item1','item2'], 'key1':123}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This clearly shows that dictionaries are not ordered."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Mutability**: Dictionaries are mutable meaning that when a dictionary is created, the elements within it can be changed or replaced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a['key1'] = 125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 125, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ITEM0'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Can then even call methods on that value\n",
    "a['key3'][0].upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can affect the values of a key as well. For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Subtract from the value\n",
    "a['key1'] = a['key1'] - 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 113, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just a quick note: In Python, there's a convenient built-in method for performing self-subtraction, addition, multiplication, or division. Alternatively, we could use the += -= *= /= etc. operators. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a['key1'] /= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 56.5, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Dictionary_Operators'></a>\n",
    "\n",
    "## 5.5. Dictionary Operators:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`in`**: Python also provides a membership operator that can be used with dictionaries. The in operator returns True if a key exists in the dictionary, and False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'key1' in a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`not in`**: Python also provides a membership operator that can be used with dictionaries. The not in operator returns True if a key doesn't exist in the dictionary, and False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'key1' not in a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Builtin_Dictionary_Methods'></a>\n",
    "\n",
    "## 5.6. Built-in Dictionary Methods:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th>Method</th>\n",
    "      <th>Description</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td>keys()</td>\n",
    "      <td>return a list of all keys</td>\n",
    "    </tr> \n",
    "    <tr>\n",
    "      <td>values()</td>\n",
    "      <td>return a list of all values</td>\n",
    "    </tr>    \n",
    "    <tr>\n",
    "      <td>items()</td>\n",
    "      <td>return tuples of all items</td>\n",
    "    </tr>  \n",
    "    <tr>\n",
    "      <td>update(2nd dic)</td>\n",
    "      <td>Merge two dictionaries</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>get(key)</td>\n",
    "      <td>returns the value for a given key</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>pop(key)</td>\n",
    "      <td>removes the specified ke0value pair from the dictionary and return the value of the removed key</td>\n",
    "    </tr>      \n",
    "    <tr>\n",
    "      <td>popitem()</td>\n",
    "      <td>removes and returns an arbitrary key-value pair from the dictionary as a tuple</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>clear()</td>\n",
    "      <td>empties dictionary of all key-value pairs</td>\n",
    "    </tr>      \n",
    "  </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['key1', 'key2', 'key3'])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([56.5, [12, 23, 33], ['item0', 'item1', 'item2']])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('key1', 56.5), ('key2', [12, 23, 33]), ('key3', ['item0', 'item1', 'item2'])])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'one': 1, 'two': 2, 'three': 3, 'four': 4}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = {'one':1, 'two':2}\n",
    "c = {'three': 3, 'four': 4}\n",
    "\n",
    "b.update(c)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of using `.update()` method, you can add a new key-value pair in the following way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "a['programming'] = 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 56.5, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2'], 'programming': 'Python'}\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can't directly concatenate dictionaries using the `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56.5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.get('key1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`.get()` is equivalent to `dictionary_name[key_name]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56.5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a['key1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.pop('programming')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 56.5, 'key2': [12, 23, 33], 'key3': ['item0', 'item1', 'item2']}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed Key: key3\n",
      "Removed Value: ['item0', 'item1', 'item2']\n",
      "Updated Dictionary: {'key1': 56.5, 'key2': [12, 23, 33]}\n"
     ]
    }
   ],
   "source": [
    "key_pop, value_pop = a.popitem()\n",
    "\n",
    "print('Removed Key:', key_pop)\n",
    "print('Removed Value:', value_pop)\n",
    "print('Updated Dictionary:', a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Nesting_Dictionaries'></a>\n",
    "\n",
    "## 5.7. Nesting Dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic1 = {'key1':{'nestkey':{'subnestkey':'value'}}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Keep calling the keys\n",
    "dic1['key1']['nestkey']['subnestkey']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries and lists share the following characteristics:\n",
    "\n",
    "- Both are mutable.\n",
    "- Both are dynamic: They can grow and shrink as needed.\n",
    "- Both can be nested: A list can contain another list. A dictionary can contain another dictionary. A dictionary can also contain a list, and vice versa.\n",
    "\n",
    "Dictionaries differ from lists primarily in how elements are accessed:\n",
    "\n",
    "- List elements are accessed by their position in the list, via indexing.\n",
    "- Dictionary elements are accessed via keys."
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}