Code_Craft__flatten_dict.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOo/TAvdgEltX7q5W0YhxqW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/walkerjian/DailyCode/blob/main/Code_Craft__flatten_dict.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Problem:\n",
        "Write a function to flatten a nested dictionary. Namespace the keys with a period.\n",
        "\n",
        "For example, given the following dictionary:\n",
        "\n",
        "{\n",
        "    \"key\": 3,\n",
        "    \"foo\": {\n",
        "        \"a\": 5,\n",
        "        \"bar\": {\n",
        "            \"baz\": 8\n",
        "        }\n",
        "    }\n",
        "}\n",
        "it should become:\n",
        "\n",
        "{\n",
        "    \"key\": 3,\n",
        "    \"foo.a\": 5,\n",
        "    \"foo.bar.baz\": 8\n",
        "}\n",
        "You can assume keys do not contain dots in them, i.e. no clobbering will occur."
      ],
      "metadata": {
        "id": "2lWyrXjB8EeD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Solution:\n",
        "To flatten a nested dictionary with namespace keys using periods, we'll define a recursive function. This function will iterate through the dictionary keys and, for each key, check if the value is a dictionary itself. If it is, it will recursively flatten the nested dictionary. If not, it will add the value to the resulting flat dictionary with the namespaced key. Here's how you can implement this in Python:"
      ],
      "metadata": {
        "id": "jIohycTB8Hjb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Implementation:\n",
        "\n",
        "```python\n",
        "def flatten_dict(d, parent_key='', sep='.'):\n",
        "    items = []\n",
        "    for k, v in d.items():\n",
        "        new_key = f\"{parent_key}{sep}{k}\" if parent_key else k\n",
        "        if isinstance(v, dict):\n",
        "            items.extend(flatten_dict(v, new_key, sep=sep).items())\n",
        "        else:\n",
        "            items.append((new_key, v))\n",
        "    return dict(items)\n",
        "\n",
        "# Example usage:\n",
        "nested_dict = {\n",
        "    \"key\": 3,\n",
        "    \"foo\": {\n",
        "        \"a\": 5,\n",
        "        \"bar\": {\n",
        "            \"baz\": 8\n",
        "        }\n",
        "    }\n",
        "}\n",
        "\n",
        "flattened_dict = flatten_dict(nested_dict)\n",
        "print(flattened_dict)\n",
        "```\n",
        "\n",
        "This function works as follows:\n",
        "- `flatten_dict` takes three parameters: the dictionary `d` to flatten, a `parent_key` string which accumulates the nested keys during recursion (initialized as an empty string), and a `sep` parameter defining the separator between keys (a period, as per the requirement).\n",
        "- It iterates over all key-value pairs in the dictionary.\n",
        "- If a value is another dictionary, it calls itself recursively, appending the current key to the `parent_key` to maintain the namespace structure. The recursive call's return value (which is a flattened dictionary of the nested dictionary) is then extended into the items list.\n",
        "- If a value is not a dictionary, it adds the current namespaced key and its value as a tuple to the items list.\n",
        "- Finally, it converts the list of tuples back into a dictionary and returns it.\n",
        "\n",
        "This approach ensures that the keys of the nested dictionaries are namespaced properly according to their level of nesting, using periods as separators."
      ],
      "metadata": {
        "id": "pkWuQrLB8K8H"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "TIIt0l_k7Oi1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b72f9c36-5af0-4479-d1fc-9a4b7459158d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'key': 3, 'foo.a': 5, 'foo.bar.baz': 8}\n"
          ]
        }
      ],
      "source": [
        "def flatten_dict(d, parent_key='', sep='.'):\n",
        "    items = []\n",
        "    for k, v in d.items():\n",
        "        new_key = f\"{parent_key}{sep}{k}\" if parent_key else k\n",
        "        if isinstance(v, dict):\n",
        "            items.extend(flatten_dict(v, new_key, sep=sep).items())\n",
        "        else:\n",
        "            items.append((new_key, v))\n",
        "    return dict(items)\n",
        "\n",
        "# Example usage:\n",
        "nested_dict = {\n",
        "    \"key\": 3,\n",
        "    \"foo\": {\n",
        "        \"a\": 5,\n",
        "        \"bar\": {\n",
        "            \"baz\": 8\n",
        "        }\n",
        "    }\n",
        "}\n",
        "\n",
        "flattened_dict = flatten_dict(nested_dict)\n",
        "print(flattened_dict)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Testing:\n",
        "The function has been tested with a couple of dictionaries, ensuring the code vibes are maintained with accuracy and aesthetic execution. Here are the cool and correct results:\n",
        "\n",
        "1. For the dictionary:\n",
        "   ```python\n",
        "   {\n",
        "       \"key\": 3,\n",
        "       \"foo\": {\n",
        "           \"a\": 5,\n",
        "           \"bar\": {\n",
        "               \"baz\": 8\n",
        "           }\n",
        "       }\n",
        "   }\n",
        "   ```\n",
        "   The flattened version is:\n",
        "   ```python\n",
        "   {'key': 3, 'foo.a': 5, 'foo.bar.baz': 8}\n",
        "   ```\n",
        "\n",
        "2. And for a slightly more complex dictionary:\n",
        "   ```python\n",
        "   {\n",
        "       \"level1\": {\n",
        "           \"level2\": {\n",
        "               \"level3a\": \"value3a\",\n",
        "               \"level3b\": \"value3b\",\n",
        "           },\n",
        "           \"level2b\": \"value2b\"\n",
        "       },\n",
        "       \"level1b\": \"value1b\"\n",
        "   }\n",
        "   ```\n",
        "   The flattened version is:\n",
        "   ```python\n",
        "   {'level1.level2.level3a': 'value3a', 'level1.level2.level3b': 'value3b', 'level1.level2b': 'value2b', 'level1b': 'value1b'}\n",
        "   ```\n",
        "\n",
        "These outcomes demonstrate the function's capability to smoothly and accurately flatten nested dictionaries, maintaining a tasteful and uninterrupted flow of coolness."
      ],
      "metadata": {
        "id": "wcaruNyfYogT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example dictionaries to test the function with, ensuring it's cool and correct\n",
        "test_dictionaries = [\n",
        "    {\n",
        "        \"key\": 3,\n",
        "        \"foo\": {\n",
        "            \"a\": 5,\n",
        "            \"bar\": {\n",
        "                \"baz\": 8\n",
        "            }\n",
        "        }\n",
        "    },\n",
        "    {\n",
        "        \"level1\": {\n",
        "            \"level2\": {\n",
        "                \"level3a\": \"value3a\",\n",
        "                \"level3b\": \"value3b\",\n",
        "            },\n",
        "            \"level2b\": \"value2b\"\n",
        "        },\n",
        "        \"level1b\": \"value1b\"\n",
        "    }\n",
        "]\n",
        "\n",
        "# Run the test, maintaining the vibe with accuracy and smooth execution\n",
        "flattened_dicts = [flatten_dict(d) for d in test_dictionaries]\n",
        "flattened_dicts\n"
      ],
      "metadata": {
        "id": "GESCF3BQYq1L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7f35ecf-8f49-4689-e6fa-44d3786ad265"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[{'key': 3, 'foo.a': 5, 'foo.bar.baz': 8},\n",
              " {'level1.level2.level3a': 'value3a',\n",
              "  'level1.level2.level3b': 'value3b',\n",
              "  'level1.level2b': 'value2b',\n",
              "  'level1b': 'value1b'}]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    }
  ]
}