DS_Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures or Derived data Types in Python:\n",
    "\n",
    "Storing multiple values of same or different types under a single name.\n",
    "They are collection of data.\n",
    "\n",
    "1. List\n",
    "2. Tuple\n",
    "3. String\n",
    "4. Dictionary\n",
    "5. Set  \n",
    "In this notebook, we'll discuss indepth on Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary:\n",
    "Dictionaries are unordered collection of data.\n",
    "They are key-value mapping.  \n",
    "Represented by Curly braces `{}`  \n",
    "\n",
    "```python\n",
    "dictionary : {1: 10, 2: 20, 3: 30, 4: 'Hello', 5: -2.0}\n",
    "```\n",
    "\n",
    "Defined by - key : value.  \n",
    "Each key-value map is separated by comma (,)\n",
    "\n",
    "|Keys| 1| 2| 3| 4| 5|  \n",
    "|---|---|---|---|---|---|  \n",
    "|Values| 10| 20| 30| 40| 50|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a dictionary:\n",
    "\n",
    "1. '{ }'\n",
    "2. dict()\n",
    "\n",
    "### 1. '{}'\n",
    "```python\n",
    "dict1 = {1:10, 2:20, 3:30}\n",
    "```\n",
    "### 2. dict()\n",
    "Syntax: \n",
    "```python\n",
    "dict(iterable = None)\n",
    "```  \n",
    "iterable: any data structures listed above given that elements are present as key value mapping. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {}\n",
    "type(d1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 10, 2: 20, 3: 35}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [(1, 10), (2, 20), (3, 35)]\n",
    "d2 = dict(l)\n",
    "print(d2)\n",
    "type(d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods or Functions in dictionaries:  \n",
    "There are various methods or functions that are used to work with dictionaries.  \n",
    "1. len  \n",
    "2. str   \n",
    "3. clear  \n",
    "4. copy  \n",
    "5. fromkeys  \n",
    "6. get  \n",
    "8. items  \n",
    "9. keys  \n",
    "10. values   \n",
    "11. update  \n",
    "12. pop\n",
    "13. popitem\n",
    "10. setdefault "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. len:\n",
    "Returns the length of the given iterable.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "len(iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "len(d1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. str:\n",
    "Returns the string format of the given dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "str(dict)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{1: 12, 2: 23, 3: 34}'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "str(d1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. clear:\n",
    "Deletes the items in the dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.clear()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.clear()\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. copy:\n",
    "Returns the shallow copy of the given dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.copy()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 12, 2: 23, 3: 34}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d2 = d1.copy()\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. fromkeys:\n",
    "Returns  a new dictionary form the given list of keys. By default the values are set to None.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.fromkeys(sep, val = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': None, 'key2': None, 'key3': None}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key = ['key1', 'key2', 'key3']\n",
    "d2 = dict.fromkeys(key)\n",
    "d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 0, 'key2': 0, 'key3': 0}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key = ['key1', 'key2', 'key3']\n",
    "d2 = dict.fromkeys(key, 0)\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. get:\n",
    "Returns the value of the given key if present else returns the default value given (None by Default).\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.get(key, default = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.get(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "print(d1.get(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.get(4, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. items:\n",
    "Returns the list of key-value pairs in the dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.items()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([(1, 12), (2, 23), (3, 34)])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. keys:\n",
    "Returns the list of keys present in the dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.keys()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([1, 2, 3])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. values:\n",
    "Returns the list of values present on the dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.values()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([12, 23, 34])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. update:\n",
    "Adds the key-value pairs in second dictionary to the first.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.update(dict)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 12, 2: 23, 3: 34, 4: 45, 5: 56}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d2 = {4: 45, 5: 56}\n",
    "d1.update(d2)\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. pop:\n",
    "Removes and returns the value of given key. If the key is absent, Error is raised if default is not given.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.pop(key, [default])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 12, 3: 34}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "print(d1.pop(2))\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "4",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-31-59e0c7377e6c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0md1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m12\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m23\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m34\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0md1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 4"
     ]
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "print(d1.pop(4))\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 12, 2: 23, 3: 34}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "print(d1.pop(4, 30))\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. popitem:\n",
    "Removes and returns the last key-value pair of the dictionary.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.popitem()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 34)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 12, 2: 23}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "print(d1.popitem())\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13. setdefault:\n",
    "Sets the default value to key if the key is absent.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict.setdefault(key, value)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 12, 2: 23, 3: 34, 4: 45}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1.setdefault(4, 45)\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing elements:\n",
    "The values in the dictionary are accessed by key.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dictionary[key]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 22: 23, 3: 34}\n",
    "d1[22]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "4",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-d109a962441b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0md1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m12\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m23\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m34\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0md1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 4"
     ]
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding or Modifying items:\n",
    "Items can be added or modified by using keys.\n",
    "\n",
    "If the key already exists, the value is replcaed by the new value. If not, new key-value pair is created\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dictaionary[key] = value\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 12, 2: 24, 3: 34, 4: 45}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "d1[2] = 24 # modify\n",
    "d1[4] = 45 # add\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delete Elements:\n",
    "Elements can be deleted by using the *del* keyword.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "del dict[key]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 12}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "del d1[2], d1[3]\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing Items:\n",
    "Use for loop to iterate through the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 12\n",
      "2 23\n",
      "3 34\n"
     ]
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "for key, val in d1.items():\n",
    "    print(key, val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting a dictionary:\n",
    "Dictionaries are sorted only by keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 12\n",
      "2 23\n",
      "3 34\n",
      "\n",
      "1 12\n",
      "2 23\n",
      "3 34\n"
     ]
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 3: 34}\n",
    "for i in sorted(d1.keys()):\n",
    "    print(i, d1[i])\n",
    "print()\n",
    "for i in sorted(d1):\n",
    "    print(i, d1[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested Dictionaries:\n",
    "Dictionaries inside a dictionary is nested dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 12\n",
      "2 23\n",
      "d {1: 12, 2: 23, 3: 34}\n"
     ]
    }
   ],
   "source": [
    "d1 = {1: 12, 2: 23, 'd': {1: 12, 2: 23, 3: 34}}\n",
    "for i,j in d1.items():\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries and list Comprehension:\n",
    "Dictionaries can be defined by comprehensions.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "dict = {key: value (loops)}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2 = {x: x**2 for x in range(10)}\n",
    "d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries for switch case:\n",
    "Dictionaries can be used as switch cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "switch = {1: 'One',\n",
    "          2: 'Two', \n",
    "          3: 'Three'}\n",
    "switch[1]"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}