mydictionaries.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.5.4"
    },
    "colab": {
      "name": "dictionaries.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "3qdEo0LT2kuU",
        "RrFkmtr82kuX",
        "ztxcDuSQ2kug",
        "iofDMwdK2kui",
        "d-Ddm3LX2kum",
        "S51TL3Co2kuo",
        "_VWzY5AT2kur",
        "tLRTalRjY8tz"
      ]
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6MNOxo552kt7"
      },
      "source": [
        "# [Dictionaries](https://docs.python.org/3/library/stdtypes.html#dict) \n",
        "Collections of `key`-`value` pairs. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LomL23b02kt-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "582bdc93-f3fe-4414-fc10-09f6cb112d1c"
      },
      "source": [
        "my_empty_dict = {}  # alternative: my_empty_dict = dict()\n",
        "print('dict: {}, type: {}'.format(my_empty_dict, type(my_empty_dict)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict: {}, type: <class 'dict'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ROOtpS22kuF"
      },
      "source": [
        "## Initialization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XJIEJ-wdn_tL"
      },
      "source": [
        "mydiction= {}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IM2MFfHXoB8D",
        "outputId": "56327ecb-e646-4b89-9f23-39979e92b9e0"
      },
      "source": [
        "type(mydiction)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-yC3Vu8GyRR"
      },
      "source": [
        "dict11 = {'key1': 1.6, 'key2': 10, 'key3': 'John Doe'}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ws0TXNtBG6qU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "777a66d2-80c5-4228-d95f-391798904c1b"
      },
      "source": [
        "dict11"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'key1': 1.6, 'key2': 10, 'key3': 'John Doe'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a0PoPShHnqPM"
      },
      "source": [
        "dict11['key4']=11"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KzWC1eqnG_-a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba8af082-50eb-4e2f-f8dc-2683d20aa164"
      },
      "source": [
        "dict22 = dict(key1=1.6, key2=10, key3='John Doe')\n",
        "dict22"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'key1': 1.6, 'key2': 10, 'key3': 'John Doe'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WxEMTAmLonY2"
      },
      "source": [
        "mydiction = {0:'hello'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y3AnIRMdonfP",
        "outputId": "42a96f50-750d-4090-8d9d-4b8344999736"
      },
      "source": [
        "mydiction"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{0: 'hello', 1: '10', 2: '20', 3: '30', 4: '40', 5: '50'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2UDewgDRongl",
        "outputId": "43e250f0-44b2-40a7-adc3-1a5c0d867fd6"
      },
      "source": [
        "i=1\r\n",
        "while(i<=5):\r\n",
        "  mydiction[i]=input(\"Enter the number\")\r\n",
        "  i+=1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the number10\n",
            "Enter the number20\n",
            "Enter the number30\n",
            "Enter the number40\n",
            "Enter the number50\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLwtnRyAq_Nc"
      },
      "source": [
        "mymatrix=[[1,2,3],[4,5,6],[7,8,9]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HPG_2Ap5rKyE",
        "outputId": "91f7d3e6-9246-4422-af4b-5e2d58d727d7"
      },
      "source": [
        "print(mymatrix)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rs6AY3LlrSyM",
        "outputId": "ed7d7d08-be12-4093-fb2b-f0026d6a3df1"
      },
      "source": [
        "mymatrix[1][0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UlK_saGZr0mm",
        "outputId": "39705011-63f5-42fc-8979-de14a5a6c642"
      },
      "source": [
        "mymatrix[2][0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u_85jeV5r6Uf",
        "outputId": "daf3b283-f87d-4cbc-a837-eeca86938655"
      },
      "source": [
        "mymatrix"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9S7YXbmXr9GZ"
      },
      "source": [
        "#sparse matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DguQ55u8r--y"
      },
      "source": [
        "mymatrix=[[0,2,0],[4,0,0],[0,0,9]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yqMsmgtCsHhO",
        "outputId": "2cb45f74-f99f-46b4-dc85-e2a064047048"
      },
      "source": [
        "mymatrix"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[0, 2, 0], [4, 0, 0], [0, 0, 9]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DfVQHG_9sK4M",
        "outputId": "fdf80030-0312-4781-98d0-66021f10a72d"
      },
      "source": [
        "mymatrix[0][1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YC6mVXvVsMri",
        "outputId": "fd174620-dded-408e-c0a8-57c87c3e2d5d"
      },
      "source": [
        "mymatrix[1][0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vtm9UkXJsNGh",
        "outputId": "8d0fbe61-2a99-47a1-de21-5fad1c7e7895"
      },
      "source": [
        "mymatrix[2][2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Pdf3Tp8sops"
      },
      "source": [
        "#Dict"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vJaNH8A1soBE"
      },
      "source": [
        "mydiction = {(0,1):2,(2,0):4,(2,2):9}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MPdWG5adsoNP",
        "outputId": "10711d95-a42a-480f-8248-a9e55e49b1bf"
      },
      "source": [
        "mydiction"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{(0, 1): 2, (2, 0): 4, (2, 2): 9}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TtB_LkYgHf6p"
      },
      "source": [
        "previous={0:0, 1:1}\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1uJO6lYk00t_"
      },
      "source": [
        "if n not in previous:\r\n",
        "  previous[n]=value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N4qBEJuP06h6",
        "outputId": "0d181e9a-a7d9-42cd-ab28-1c9e03d41411"
      },
      "source": [
        "previous"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{0: 0, 1: 1, 2: 2}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrazH2VyHiIn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b85ac5c0-2c51-4285-a8be-4c6cd02ad23d"
      },
      "source": [
        "import time\n",
        "def fibonacci(n):\n",
        "    if n not in previous:\n",
        "        #print(\"Inside this if\")\n",
        "        val=fibonacci(n-1)+fibonacci(n-2)\n",
        "        previous[n]=val\n",
        "    return previous[n]\n",
        "n=int(input(\"Enter the value of n:\"))\n",
        "start_time = time.time()\n",
        "print(\"Fibonacci(\", n,\")= \", fibonacci(n))\n",
        "print(\"Time:% \",(time.time() - start_time))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the value of n:100\n",
            "Fibonacci( 100 )=  354224848179261915075\n",
            "Time:%  0.0007901191711425781\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gNW03Y7j2kuG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8930a522-a5d9-4c13-9e8f-2a8b52d928f0"
      },
      "source": [
        "dict1 = {'value1': 1.6, 'value2': 10, 'name': 'John Doe'}\n",
        "dict2 = dict(value1=1.6, value2=10, name='John Doe')\n",
        "\n",
        "print(dict1)\n",
        "print(dict2)\n",
        "\n",
        "print('equal: {}'.format(dict1 == dict2))\n",
        "print('length: {}'.format(len(dict2)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'value1': 1.6, 'value2': 10, 'name': 'John Doe'}\n",
            "{'value1': 1.6, 'value2': 10, 'name': 'John Doe'}\n",
            "equal: True\n",
            "length: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LdVcsBFY2kuK"
      },
      "source": [
        "## `dict.keys(), dict.values(), dict.items()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2XZ2kmR32kuK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68ecc61d-b5e3-4f12-ce7c-731fb246b1f6"
      },
      "source": [
        "print('keys: {}'.format(dict1.keys()))\n",
        "print('values: {}'.format(dict1.values()))\n",
        "print('items: {}'.format(dict1.items()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "keys: dict_keys(['value1', 'value2', 'name'])\n",
            "values: dict_values([1.6, 10, 'John Doe'])\n",
            "items: dict_items([('value1', 1.6), ('value2', 10), ('name', 'John Doe')])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wZMJRrYsINql",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a029f89a-4689-4540-e3fb-02eba0a2d49e"
      },
      "source": [
        "print('keys: {}'.format(dict11.keys()))\n",
        "print('values: {}'.format(dict11.values()))\n",
        "print('items: {}'.format(dict11.items()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "keys: dict_keys(['key1', 'key2', 'key3'])\n",
            "values: dict_values([1.6, 10, 'John Doe'])\n",
            "items: dict_items([('key1', 1.6), ('key2', 10), ('key3', 'John Doe')])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k2GYM-q72kuO"
      },
      "source": [
        "## Accessing and setting values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wtEfpTuMIbaC"
      },
      "source": [
        "my_dict = {}\n",
        "my_dict['key1'] = 'value1'\n",
        "my_dict['key2'] = 99"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TLgHurn0IcWY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "154b4f2c-3d13-48db-ecd8-ba7dc3839f42"
      },
      "source": [
        "my_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'key1': 'value1', 'key2': 99}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RWh6S4nXIkxj"
      },
      "source": [
        "my_dict['key1'] = 'new value'  # overriding existing value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g44klLA_Ilpn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb20be7f-3e72-47d1-d0cd-6997ddb2ec01"
      },
      "source": [
        "my_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'key1': 'new value', 'key2': 99}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LsHmi_hX2kuO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c7779452-c364-487a-a624-e876a80b95c6"
      },
      "source": [
        "my_dict = {}\n",
        "my_dict['key1'] = 'value1'\n",
        "my_dict['key2'] = 99\n",
        "my_dict['key1'] = 'new value'  # overriding existing value\n",
        "print(my_dict)\n",
        "print('value of key1: {}'.format(my_dict['key1']))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'key1': 'new value', 'key2': 99}\n",
            "value of key1: new value\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4FlCt4ku2kuS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "outputId": "7eee0c5c-abb1-48e4-be36-9d6ea76e22b6"
      },
      "source": [
        "print(my_dict['key3'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-18-698a57942b37>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'key3'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'key3'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qdEo0LT2kuU"
      },
      "source": [
        "## Deleting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N4DcKbdxJHAj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "acdb599d-2c80-46c1-aafe-ee4e68210cca"
      },
      "source": [
        "my_dict = {'key1': 'value1', 'key2': 99, 'keyX': 'valueX'}\n",
        "del my_dict['keyX']\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'key1': 'value1', 'key2': 99}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OlX-iwuVJJRZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "outputId": "c6de7193-161b-44b3-ad90-8d564afc5cb8"
      },
      "source": [
        "del my_dict['keyX']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-b83a6d5a886e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'keyX'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'keyX'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "89rnem4aJRaQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44045100-3e36-4a3b-88a9-97a554aad0f6"
      },
      "source": [
        "key_to_delete = 'key1'\n",
        "if key_to_delete in my_dict:\n",
        "    del my_dict[key_to_delete]\n",
        "    print(my_dict)\n",
        "else:\n",
        "    print('{key} is not in {dictionary}'.format(key=key_to_delete, dictionary=my_dict))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'key2': 99}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-_EYhUeS2kuV",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "dc1e663e-22cc-4c49-bdb0-0d758f179a78"
      },
      "source": [
        "my_dict = {'key1': 'value1', 'key2': 99, 'keyX': 'valueX'}\n",
        "del my_dict['keyX']\n",
        "print(my_dict)\n",
        "# Usually better to make sure that the key exists (see also pop() and popitem())\n",
        "key_to_delete = 'my_key'\n",
        "if key_to_delete in my_dict:\n",
        "    del my_dict[key_to_delete]\n",
        "else:\n",
        "    print('{key} is not in {dictionary}'.format(key=key_to_delete, dictionary=my_dict))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'key1': 'value1', 'key2': 99}\n",
            "my_key is not in {'key1': 'value1', 'key2': 99}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RrFkmtr82kuX"
      },
      "source": [
        "## Dictionaries are mutable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b3iSwalnNtVH"
      },
      "source": [
        "my_dict = {'ham': 'good', 'carrot': 'semi good'}\n",
        "my_other_dict = my_dict"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nl8P8Db9Nuxl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f798eedd-aab0-437e-ac67-de760a80fc57"
      },
      "source": [
        "my_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'carrot': 'super tasty', 'ham': 'good'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sQpNnwU1NxRa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f5af057-679b-4dc6-8960-953b61a514a2"
      },
      "source": [
        "my_other_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'carrot': 'super tasty', 'ham': 'good'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t6e2pGEQN14s"
      },
      "source": [
        "my_other_dict['carrot'] = 'super tasty'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rS98jPZc2kuY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "490b3919-028c-4de8-de30-613ebd49b057"
      },
      "source": [
        "my_dict = {'ham': 'good', 'carrot': 'semi good'}\n",
        "my_other_dict = my_dict\n",
        "my_other_dict['carrot'] = 'super tasty'\n",
        "my_other_dict['sausage'] = 'best ever'\n",
        "print('my_dict: {}\\nother: {}'.format(my_dict, my_other_dict))\n",
        "print('equal: {}'.format(my_dict == my_other_dict))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "my_dict: {'ham': 'good', 'carrot': 'super tasty', 'sausage': 'best ever'}\n",
            "other: {'ham': 'good', 'carrot': 'super tasty', 'sausage': 'best ever'}\n",
            "equal: True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZLSeMhK92kud"
      },
      "source": [
        "Create a new `dict` if you want to have a copy:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "apfCN7kV2kud",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2f6c2b93-8c96-46e4-9bf3-7aeeb46566e1"
      },
      "source": [
        "my_dict = {'ham': 'good', 'carrot': 'semi good'}\n",
        "my_other_dict = dict(my_dict)\n",
        "my_other_dict['beer'] = 'decent'\n",
        "print('my_dict: {}\\nother: {}'.format(my_dict, my_other_dict))\n",
        "print('equal: {}'.format(my_dict == my_other_dict))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "my_dict: {'ham': 'good', 'carrot': 'semi good'}\n",
            "other: {'ham': 'good', 'carrot': 'semi good', 'beer': 'decent'}\n",
            "equal: False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1k2gP3mROSlf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1bcac244-e6e5-4f18-ac1d-a502437d7c9c"
      },
      "source": [
        "my_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'carrot': 'semi good', 'ham': 'good'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LRX6u-XROWZJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "83a04646-5f49-4988-f117-26500dc238d0"
      },
      "source": [
        "my_other_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'beer': 'decent', 'carrot': 'semi good', 'ham': 'good'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ztxcDuSQ2kug"
      },
      "source": [
        "<a id='dict_get'></a>\n",
        "## `dict.get()`\n",
        "Returns `None` if `key` is not in `dict`. However, you can also specify `default` return value which will be returned if `key` is not present in the `dict`. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DQT1nk5R2kug",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d90a3c9d-7cf6-4daa-bbff-a8eca57f5b79"
      },
      "source": [
        "my_dict = {'a': 1, 'b': 2, 'c': 3}\n",
        "d = my_dict.get('a')\n",
        "print('d: {}'.format(d))\n",
        "\n",
        "d = my_dict.get('e', 'No Value')\n",
        "print('d: {}'.format(d))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "d: 1\n",
            "d: No Value\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iofDMwdK2kui"
      },
      "source": [
        "## `dict.pop()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q4R6c5Fc2kuj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17914f71-2243-464c-9806-c70f3ac6eea7"
      },
      "source": [
        "my_dict = dict(food='ham', drink='beer', sport='football')\n",
        "print('dict before pops: {}'.format(my_dict))\n",
        "\n",
        "food = my_dict.pop('food')\n",
        "print('food: {}'.format(food))\n",
        "print('dict after popping food: {}'.format(my_dict))\n",
        "\n",
        "food_again = my_dict.pop('sport', 'default value for food')\n",
        "print('food again: {}'.format(food_again))\n",
        "print('dict after popping food again: {}'.format(my_dict))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict before pops: {'food': 'ham', 'drink': 'beer', 'sport': 'football'}\n",
            "food: ham\n",
            "dict after popping food: {'drink': 'beer', 'sport': 'football'}\n",
            "food again: football\n",
            "dict after popping food again: {'drink': 'beer'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "apoLRDcjPfBf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "933f4d23-2832-4326-a7d9-1be61648937c"
      },
      "source": [
        "food_again = my_dict.pop('drink', 'default value for food')\n",
        "food_again"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'default value for food'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vnaw5xUDPh7L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ef8728b-ead9-4720-ae2c-fc9125a4ae4e"
      },
      "source": [
        "my_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nntfJlp0AfIq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "0c9516a1-04a0-4cf3-8f95-d59de409c28e"
      },
      "source": [
        "my_dict = dict(food='ham', drink='beer', sport='football')\n",
        "print('dict before pops: {}'.format(my_dict))\n",
        "\n",
        "result = my_dict.popitem()\n",
        "print('Result: {}'.format(result))\n",
        "print('dict after popping items: {}'.format(my_dict))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict before pops: {'food': 'ham', 'drink': 'beer', 'sport': 'football'}\n",
            "Result: ('sport', 'football')\n",
            "dict after popping items: {'food': 'ham', 'drink': 'beer'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d-Ddm3LX2kum"
      },
      "source": [
        "## `dict.setdefault()`\n",
        "Returns the `value` of `key` defined as first parameter. If the `key` is not present in the dict, adds `key` with default value (second parameter)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hfc7dC2d2kum",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fb38403-4e58-4756-f29f-e9489d52da69"
      },
      "source": [
        "my_dict = {'a': 1, 'b': 2, 'c': 3}\n",
        "#a = my_dict.setdefault('a', 'my default value')\n",
        "d = my_dict.setdefault('d', 'my default value')\n",
        "print('a: {}\\nd: {}\\nmy_dict: {}'.format(a, d, my_dict))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a: 1\n",
            "d: my default value\n",
            "my_dict: {'a': 1, 'b': 2, 'c': 3, 'd': 'my default value'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S51TL3Co2kuo"
      },
      "source": [
        "## `dict.update()`\n",
        "Merge two `dict`s"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Nc-fmGN2kup",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "03266878-ada6-456b-be37-412f0238ac6b"
      },
      "source": [
        "dict1 = {'a': 1, 'b': 2}\n",
        "dict2 = {'c': 3}\n",
        "dict1.update(dict2)\n",
        "print(dict1)\n",
        "\n",
        "\n",
        "# If they have same keys:\n",
        "dict1.update({'c': 10})\n",
        "print(dict1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'a': 1, 'b': 2, 'c': 3}\n",
            "{'a': 1, 'b': 2, 'c': 10}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VWzY5AT2kur"
      },
      "source": [
        "## The keys of a `dict` have to be immutable"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "it6FE5E52kur"
      },
      "source": [
        "Thus you can not use e.g. a `list` or a `dict` as key because they are mutable types\n",
        ":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pt-j9tmK2kur",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "outputId": "8bae8cb8-1b71-494f-dd8d-23683bfc880e"
      },
      "source": [
        " bad_dict = {['my_list'], 'value'}  # Raises TypeError"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-55-a3d6b5ab5071>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbad_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'my_list'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'value'\u001b[0m\u001b[0;34m}\u001b[0m  \u001b[0;31m# Raises TypeError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-XxY3WWQQWKq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bda41724-dac6-48e7-ede4-c233ffe9ae81"
      },
      "source": [
        " bad_dict = {'my_list', 'value'}  \n",
        " bad_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'my_list', 'value'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wtOa6uV22kuu"
      },
      "source": [
        "Values can be mutable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SR5E-qPR2kuu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2365138f-d5a9-46e1-965d-964247a40dea"
      },
      "source": [
        "good_dict = {'my key': ['Python', 9.1, 3, 'cool']}\n",
        "print(good_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'my key': ['Python', 9.1, 3, 'cool']}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5YjIbYkUgCl"
      },
      "source": [
        "#Aliasing and copying"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PGm5DOUDBr-x"
      },
      "source": [
        "my_dict = dict(food='ham', drink='beer', sport='football')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y2ffEyV8msbV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "381ac0d6-d22b-4955-ecb9-a2ab3bfe09ec"
      },
      "source": [
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'food': 'ham', 'drink': 'beer', 'sport': 'football'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XczGwQ_MUqFG"
      },
      "source": [
        "my_dict_copy = my_dict"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Or1PeDycU1fw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e26e28a-e13e-4c86-ae9d-5c5355b514e7"
      },
      "source": [
        "id(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "139704704947112"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MHj74hKwU2Za",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8814e78e-4ff9-46a0-cc75-d5d2fbe1eb53"
      },
      "source": [
        "id(my_dict_copy)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "139704704947112"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XFwRAlMOU4hz"
      },
      "source": [
        "my_dict_clone = my_dict.copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IzxAgO2BU_ma",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7365d351-1fd0-4bb1-e02e-0a9cf990d7f5"
      },
      "source": [
        "id(my_dict_clone)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "139704836885096"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NPXsfvdKVK_W"
      },
      "source": [
        "#Sparse matrices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ROFKPhLUVAlX"
      },
      "source": [
        "matrix = [ [0,0,0,1,0],\n",
        "[0,0,0,0,0],\n",
        "[0,2,0,0,0],\n",
        "[0,0,0,0,0],\n",
        "[0,0,0,3,0] ]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NEAHYtrdVOkP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a1abdb85-b22d-4457-e521-dd50ba5e1edf"
      },
      "source": [
        "print(matrix)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0, 0, 0, 1, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 3, 0]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uB72iZ-aVQi1"
      },
      "source": [
        "matrix = {(0,3): 1, (2, 1): 2, (4, 3): 3}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TLY2y88mVUDa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fc0f61ed-aead-47bc-8d17-2643dc952c82"
      },
      "source": [
        "print(matrix)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{(0, 3): 1, (2, 1): 2, (4, 3): 3}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZasgjMFVbMG"
      },
      "source": [
        "We only need three key-value pairs, one for each nonzero element of the matrix.\n",
        "Each key is a tuple, and each value is an integer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gvi0WwixVVdy",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        },
        "outputId": "45aeba67-c275-4925-8aa6-02827cd88826"
      },
      "source": [
        "matrix[4,2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-73-b630342e5c1f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: (4, 2)"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H5PZOC1EVuWO"
      },
      "source": [
        "Instead of two integer indices, we use\n",
        "one index, which is a tuple of integers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q5-7jK8uVygD"
      },
      "source": [
        "If we specify an element that is zero, we get an error,\n",
        "because there is no entry in the dictionary with that key:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "75fOo8PrVgK_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        },
        "outputId": "d6aa90f8-b246-4acc-db04-50f2db9b0f3c"
      },
      "source": [
        "matrix[1,3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-929764230f7e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: (1, 3)"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PdrjvUKfV255"
      },
      "source": [
        "The get method solves this problem: The first argument is the key; the second argument is the value get should\n",
        "return if the key is not in the dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hs9c9OweV0Kn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "5ad77c7f-17db-46ef-b3cc-39f2304b2f3a"
      },
      "source": [
        "matrix.get((2,1), 0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DZ2VuvWNV4_D",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a4166ef2-ed37-4713-b0c2-b52fcb08ea93"
      },
      "source": [
        "matrix.get((0,3), 0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZMA_h90zX-30"
      },
      "source": [
        "#Counting letters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tLRTalRjY8tz"
      },
      "source": [
        "<a id='dict_get'></a>\n",
        "## `dict.get()`\n",
        "Returns `None` if `key` is not in `dict`. However, you can also specify `default` return value which will be returned if `key` is not present in the `dict`. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BBwDJrZOY9DV",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "2965d4ab-72e5-474e-a2a1-6bf46d7beb78"
      },
      "source": [
        "my_dict = {'a': 1, 'b': 2, 'c': 3}\n",
        "d = my_dict.get('d')\n",
        "print('d: {}'.format(d))\n",
        "\n",
        "d = my_dict.get('c', 'value')\n",
        "print('d: {}'.format(d))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "d: None\n",
            "d: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YoKjuliFWj6s",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "outputId": "6c2960c0-76b5-45c2-9c68-d3e1c099ca19"
      },
      "source": [
        "letterCounts = {}\n",
        "print(letterCounts)\n",
        "for letter in \"Mississippi\":\n",
        "  #print(letter,letterCounts.get (letter, 0))\n",
        "  letterCounts[letter] = letterCounts.get (letter, 0) + 1\n",
        "  print(letterCounts)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{}\n",
            "{'M': 1}\n",
            "{'M': 1, 'i': 1}\n",
            "{'M': 1, 'i': 1, 's': 1}\n",
            "{'M': 1, 'i': 1, 's': 2}\n",
            "{'M': 1, 'i': 2, 's': 2}\n",
            "{'M': 1, 'i': 2, 's': 3}\n",
            "{'M': 1, 'i': 2, 's': 4}\n",
            "{'M': 1, 'i': 3, 's': 4}\n",
            "{'M': 1, 'i': 3, 's': 4, 'p': 1}\n",
            "{'M': 1, 'i': 3, 's': 4, 'p': 2}\n",
            "{'M': 1, 'i': 4, 's': 4, 'p': 2}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvEXr_nBR6FD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e2c1079-09f5-443c-ab76-210c733766db"
      },
      "source": [
        "letterCounts = {}\n",
        "print(letterCounts)\n",
        "for letter in \"Malayalam\":\n",
        "  print(letter,letterCounts.get (letter, 0))\n",
        "  letterCounts[letter] = letterCounts.get (letter, 0) + 1\n",
        "  print(letterCounts)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{}\n",
            "M 0\n",
            "{'M': 1}\n",
            "a 0\n",
            "{'M': 1, 'a': 1}\n",
            "l 0\n",
            "{'M': 1, 'a': 1, 'l': 1}\n",
            "a 1\n",
            "{'M': 1, 'a': 2, 'l': 1}\n",
            "y 0\n",
            "{'M': 1, 'a': 2, 'l': 1, 'y': 1}\n",
            "a 2\n",
            "{'M': 1, 'a': 3, 'l': 1, 'y': 1}\n",
            "l 1\n",
            "{'M': 1, 'a': 3, 'l': 2, 'y': 1}\n",
            "a 3\n",
            "{'M': 1, 'a': 4, 'l': 2, 'y': 1}\n",
            "m 0\n",
            "{'M': 1, 'a': 4, 'l': 2, 'y': 1, 'm': 1}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QjSPT17YX7Zw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e88da38c-2512-46e3-ed40-34728a9aa407"
      },
      "source": [
        "letterCounts"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'M': 1, 'a': 4, 'l': 2, 'm': 1, 'y': 1}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L1815pmPZY5-"
      },
      "source": [
        "#Exercise"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "36RZSw4Btc4m"
      },
      "source": [
        "def fib(n):\n",
        "   if n <= 1:\n",
        "       return n\n",
        "   else:\n",
        "       return(fib(n-1) + fib(n-2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h4HUl_aDaNrY"
      },
      "source": [
        "If you played around with the fibonacci function , you might\n",
        "have noticed that the bigger the argument you provide, the longer the function\n",
        "takes to run. Furthermore, the run time increases very quickly. On one of\n",
        "our machines, fibonacci(20) finishes instantly, fibonacci(30) takes about a\n",
        "second, and fibonacci(40) takes roughly forever"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DE4Xo5p8tk0L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c161e3f0-66b5-4363-cc65-29db16f23d9b"
      },
      "source": [
        "fib(4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WULI1618ahwY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e9bc6d1c-c43a-491e-c345-ed2ff86ef8cf"
      },
      "source": [
        "import time\n",
        "def fib(n):\n",
        "   if n <= 1:\n",
        "       return n\n",
        "   else:\n",
        "       return(fib(n-1) + fib(n-2))\n",
        "n=int(input(\"Enter the value of n:\"))\n",
        "start_time = time.time()\n",
        "print(\"Fibonacci(\", n,\")= \", fib(n))\n",
        "print(\"Time:% \",(time.time() - start_time))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the value of n:40\n",
            "Fibonacci( 40 )=  102334155\n",
            "Time:%  34.321211099624634\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TBFM4kb1vrms",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 728
        },
        "outputId": "e2d8d262-d262-46cd-9521-b9d630e74a55"
      },
      "source": [
        "i=0\n",
        "n=int(input(\"Enter the limit : \"))\n",
        "print(f\"{i}\\n\", end=\"\")\n",
        "i+=1\n",
        "for x in range(2,n+1):\n",
        "    print(f\"{i}\\n\",end=\"\")\n",
        "    i+=i"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the limit : 40\n",
            "0\n",
            "1\n",
            "2\n",
            "4\n",
            "8\n",
            "16\n",
            "32\n",
            "64\n",
            "128\n",
            "256\n",
            "512\n",
            "1024\n",
            "2048\n",
            "4096\n",
            "8192\n",
            "16384\n",
            "32768\n",
            "65536\n",
            "131072\n",
            "262144\n",
            "524288\n",
            "1048576\n",
            "2097152\n",
            "4194304\n",
            "8388608\n",
            "16777216\n",
            "33554432\n",
            "67108864\n",
            "134217728\n",
            "268435456\n",
            "536870912\n",
            "1073741824\n",
            "2147483648\n",
            "4294967296\n",
            "8589934592\n",
            "17179869184\n",
            "34359738368\n",
            "68719476736\n",
            "137438953472\n",
            "274877906944\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pBq4LeeHbjVl"
      },
      "source": [
        "Note the running time\n",
        "[Call graph](https://github.com/sarithdm/python/blob/master/ITT%20205%20Problem%20Solving%20using%20Python/Module%202/cg.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8CpuspHFfPGm"
      },
      "source": [
        "A call graph shows a set function frames, with lines connecting each frame to\n",
        "the frames of the functions it calls. At the top of the graph, fibonacci with\n",
        "n=4 calls fibonacci with n=3 and n=2. In turn, fibonacci with n=3 calls\n",
        "fibonacci with n=2 and n=1. And so on."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FKSus9zhfSS4"
      },
      "source": [
        "Count how many times fibonacci(0) and fibonacci(1) are called. This is an\n",
        "ine\u000ecient solution to the problem, and it gets far worse as the argument gets\n",
        "bigger."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EoehZhE1fa8T"
      },
      "source": [
        "Good solution is to keep track of values that have already been computed by\n",
        "storing them in a dictionary. A previously computed value that is stored for\n",
        "later use is called a hint. Here is an implementation of fibonacci using hints"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "72cdlQuxfiX3"
      },
      "source": [
        "#Hints"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "45sHUOsKZZFe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "671e2e25-e26d-4a3b-d946-0a7158a35203"
      },
      "source": [
        "previous={0:0, 1:1}\n",
        "def fibonacci(n):\n",
        "    if n not in previous:\n",
        "        val=fibonacci(n-1)+fibonacci(n-2)\n",
        "        previous[n]=val\n",
        "    return previous[n]\n",
        "n=int(input(\"Enter the value of n:\"))\n",
        "print(\"Fibonacci(\", n,\")= \", fibonacci(n))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the value of n:100\n",
            "Fibonacci( 100 )=  354224848179261915075\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_TZ8Ni6fo1A"
      },
      "source": [
        "The dictionary named previous keeps track of the Fibonacci numbers we already\n",
        "know. We start with only two pairs: 0 maps to 1; and 1 maps to 1.\n",
        "Whenever fibonacci is called, it checks the dictionary to determine if it contains\n",
        "the result. If it's there, the function can return immediately without\n",
        "making any more recursive calls. If not, it has to compute the new value. The\n",
        "new value is added to the dictionary before the function returns."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3YpP2UDK_Lmu"
      },
      "source": [
        "#Traversing dictionaries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c4AM4fzPX824"
      },
      "source": [
        "dict1 = {'a': 1.6, 'c': 10, 'b': 11}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_6ke903Y_SAT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1151a0a4-b8bf-4453-ae87-f1b6d378423c"
      },
      "source": [
        "for key in dict1:\n",
        "  print (key)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n",
            "c\n",
            "b\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KexxiaJkDjQp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d004dbf-89bf-4d8a-dd3b-20380934dc32"
      },
      "source": [
        "dict1.keys()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['a', 'c', 'b'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w4ebMV08DmGy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6cd5375a-297f-4a52-8f02-da3a754969d7"
      },
      "source": [
        "dict1.values()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_values([1.6, 10, 11])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__3J9JBT_eRZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33be58ca-1564-413c-fe42-ed29fc26a2cd"
      },
      "source": [
        "dict1.items()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('a', 1.6), ('c', 10), ('b', 11)])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k6Nn4bZs_8CR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f671e4b-5429-495d-e84e-5614738eedf6"
      },
      "source": [
        "for (key,value) in dict1.items():\n",
        "  print (key,value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a 1.6\n",
            "c 10\n",
            "b 11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1vrWvA_4AiuD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a172ada9-cc82-4adf-fb59-cdce018e68f4"
      },
      "source": [
        "keyslist=list(dict1.keys())\n",
        "keyslist"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'c', 'b']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68iJbHVsA2ti"
      },
      "source": [
        "keyslist.sort()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6zNPkpxEJFf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c6787611-a54b-4b4d-fd02-8846b2f8f6c3"
      },
      "source": [
        "keyslist"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'c']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1UtgNYHaANSt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "577b30c7-fcdc-4eeb-d752-33e3e78a76af"
      },
      "source": [
        "for key in keyslist:\n",
        "  print (key,dict1[key])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a 1.6\n",
            "b 11\n",
            "c 10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKkQdsylKdlk"
      },
      "source": [
        "#Reverse lookup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LLMLTt-yKgtk"
      },
      "source": [
        "Given a dictionary d and a key k, it is easy to find the corresponding value v = d[k]. This operation is called a lookup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aqXHiM8_Jgli"
      },
      "source": [
        "dict11 = {'key1': 1.6, 'key2': 10, 'key3': 'John Doe','key4':10}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rkqw7AFIJk1Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca7f91e8-8a17-43ac-9cf4-b5a54b3e3c98"
      },
      "source": [
        "value=dict11['key2']\n",
        "value"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "loANBzbsKEqf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80353d8c-50eb-4e4e-ff21-15d4d63ac077"
      },
      "source": [
        "value=dict11['key4']\n",
        "value"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CQkanaZiLBTo"
      },
      "source": [
        "But what if you have v and you want to find k? You have two problems: first, there might be more than one key that maps to the value v. Depending on the application, you might be able to pick one, or you might have to make a list that contains all of them. Second, there is no simple syntax to do a reverse lookup; you have to search."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9K0iNIqLNf_"
      },
      "source": [
        "Below function that takes a value and returns the first key that maps to that value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5lR1wu9KAnVS"
      },
      "source": [
        "def reverse_lookup(d, v):\n",
        "    for k in d:\n",
        "        if d[k] == v:\n",
        "            return k"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "stvtAI-pKjas"
      },
      "source": [
        "dict1 = {'a': 1.6, 'c': 10, 'b': 11}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CsiQBqWsLT6x",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4ac43fe9-12c9-4fc8-fb59-0c02d23faac2"
      },
      "source": [
        "reverse_lookup(dict1, 10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'c'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uas6NWEdLXxn"
      },
      "source": [
        "reverse_lookup(dict1, 12)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PzPCwNg0LaaA"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dLHevS24GfzO"
      },
      "source": [
        "#Student Ex"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KQuho2V4GhCL"
      },
      "source": [
        "dict11 = {'key1': 1.6, 'key2': 10, 'key3': 'John Doe'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IDeelDpHGhql",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57e2c70e-e459-4013-c2ed-ceebecca15f3"
      },
      "source": [
        "for key in dict11:\n",
        "  print (key)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "key1\n",
            "key2\n",
            "key3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ljPZAWoUGju6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f30a1f8a-a8d8-4b7e-f252-360bcb379ddc"
      },
      "source": [
        "for key in dict11:\n",
        "   print(dict11[key])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.6\n",
            "10\n",
            "John Doe\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L54rhoPdHsxP"
      },
      "source": [
        "dict11 = {'b': 1.6, 'c': 10, 'a': 'John Doe'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tosq5gcGa1pb"
      },
      "source": [
        "#Adding Extra work"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ewhXwlhH81r"
      },
      "source": [
        "dict12 = {'b': 1.6, 'c': 10, 'a': 'John Doe'}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lCsFLdkTa6q1",
        "outputId": "9389bc1a-1d81-4cec-92b9-5c0123653d67"
      },
      "source": [
        "for keys,values in dict12.items():\r\n",
        "  print(keys,values)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "b 1.6\n",
            "c 10\n",
            "a John Doe\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ksrnZZzibANg"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}