CH.7 Dictionary_Tricks.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QqUawYyFHy7R"
      },
      "source": [
        "# Chapter 7 Dictionary Tricks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aOJ7365CFV7c"
      },
      "source": [
        "# 7.1 Dictionary Default Values\n",
        "假設我們想建立客製化的 greeting function\n",
        "+ 不同 user 而有不同打招呼方式\n",
        "+ 碰上 KeyError 也能正常運作\n",
        "  \n",
        "以下的寫法看似很好，但有些缺點\n",
        "+ 查找了2次字典\n",
        "+ 冗長(verbose)，Hi 字串重複了2次\n",
        "+ It’s not Pythonic，跟 python 文檔的 “easier to ask for forgiveness than\n",
        "permission“(EAFP) coding style 違背\n",
        "\n",
        "> This common Python coding style assumes the existence of valid keys or attributes and catches exceptions\n",
        "if the assumption proves false"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zLM0NagzC92F"
      },
      "outputs": [],
      "source": [
        "name_for_userid = {\n",
        "  382: 'Alice',\n",
        "  950: 'Bob',\n",
        "  590: 'Dilbert',\n",
        "}\n",
        "\n",
        "def greeting(userid):\n",
        "  if userid in name_for_userid:\n",
        "    return 'Hi %s!' % name_for_userid[userid]\n",
        "  else:\n",
        "    return 'Hi there!'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "FDYaW7pQFcry",
        "outputId": "8356b5f3-94a4-4fe7-e02c-eef1c8fa6608"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hi Alice!\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Hi there!'"
            ]
          },
          "execution_count": 78,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "print(greeting(382))\n",
        "greeting(999)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ptFVx8D-VIeS"
      },
      "source": [
        "符合 EAFP 原則的寫法，運用 try except 來處理 KeyError"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KJWc-ZjBVIni"
      },
      "outputs": [],
      "source": [
        "def greeting(userid):\n",
        "  try:\n",
        "    return 'Hi %s!' % name_for_userid[userid]\n",
        "  except KeyError:\n",
        "    return 'Hi there'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P6wjEXLpHQWt"
      },
      "source": [
        "更好的寫法:  \n",
        "利用 get 來在 KeyError 時回傳預設值"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d9zFGHi0HQcc"
      },
      "outputs": [],
      "source": [
        "def greeting(userid):\n",
        "  return 'Hi %s!' % name_for_userid.get(\n",
        "  userid, 'there')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EiZjQ1a1HeQK"
      },
      "source": [
        "**Key Takeaways**\n",
        "+ Avoid explicit key in dict checks when testing for membership.\n",
        "+ EAFP-style exception handling or using the built-in get()\n",
        "method is preferable.\n",
        "+ In some cases, the collections.defaultdict class from the\n",
        "standard library can also be helpful."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wkabA3o0c-BM"
      },
      "source": [
        "# 7.2 Sorting Dictionaries for Fun and Profit\n",
        "你可以對 python dictionary 進行 iterate，但順序是無法確定的  \n",
        "  \n",
        "我們可以對字典內的 items 先進行默認排序 (比較字典的 key)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a2_K3PDMc-q7",
        "outputId": "8d9f2055-d71b-4a85-c9b4-13a8991d67ff"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[('a', 4), ('b', 3), ('c', 2), ('d', 1)]"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "xs = {'a': 4, 'c': 2, 'b': 3, 'd': 1}\n",
        "sorted(xs.items())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ap9V1i13dpQO"
      },
      "source": [
        "但如果想要自訂排序基準可使用 key function 來指定，範例指定 value 為基準並進行翻轉"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ovck77bTc-vN",
        "outputId": "8e664dd8-8968-4db6-85c4-f8f8418e0d87"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[('d', 1), ('c', 2), ('b', 3), ('a', 4)]"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sorted(xs.items(), key=lambda x: x[1], reverse=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xitZNO8ZeGFG"
      },
      "source": [
        "也能用已經實作的 operator.itemgetter 和 operator.attrgetter 來替代  \n",
        "但作者建議使用 lambda 方式因為可讀性更高"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_THg_MldeLn9",
        "outputId": "33034e67-fda1-4bf1-900d-1d01e2f95711"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[('d', 1), ('c', 2), ('b', 3), ('a', 4)]"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import operator\n",
        "sorted(xs.items(), key=operator.itemgetter(1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y4gVY9XZe49K"
      },
      "source": [
        "**Key Takeaways**\n",
        "+ When creating sorted “views” of dictionaries and other collections, you can influence the sort order with a key func.\n",
        "+ Key funcs are an important concept in Python. The most frequently used ones were even added to the operator module in\n",
        "the standard library.\n",
        "+ Functions are first-class citizens in Python. This is a powerful\n",
        "feature you’ll find used everywhere in the language."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DXkj6Ehbf42p"
      },
      "source": [
        "# 7.3 Emulating Switch/Case Statements With Dicts\n",
        "python 不支援 switch case，導致有時必須寫出一堆的 if 判斷句\n",
        "\n",
        "```python\n",
        "if cond == 'cond_a':\n",
        "  handle_a()\n",
        "elif cond == 'cond_b':\n",
        "  handle_b()\n",
        "else:\n",
        "  handle_default()\n",
        "```\n",
        "\n",
        "但我們能用 first-class functions 來改善這些 if 描述  \n",
        "first-class functions 意思是 function 能跟一般變數一樣，被作為參數傳遞或是當成回傳值\n",
        "\n",
        "```python\n",
        "func_dict = {\n",
        "  'cond_a': handle_a,\n",
        "  'cond_b': handle_b\n",
        "}\n",
        "\n",
        "cond = 'cond_a'\n",
        "func_dict[cond]()\n",
        "\n",
        "# handle default \n",
        "func_dict.get(cond, handle_default)()\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tEGBCvqxr1J7"
      },
      "source": [
        "以下的兩種寫法都能把原本冗長的 if 敘述給抽離，他們具有一樣的功能  \n",
        "  \n",
        "但還有進度的空間\n",
        "+ 例如 dispatch_dict 每次呼叫都會宣告一個暫時的字典和好幾個 lambda，更好的方式為把字典放在 function 外面  \n",
        "+ 使用 python 內建 operator 像是 operator.add, operator.mul 來取代 lambda function\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "Y0Z_KNgMmQ00"
      },
      "outputs": [],
      "source": [
        "def dispatch_if(operator, x, y):\n",
        "  if operator == 'add':\n",
        "    return x + y\n",
        "  elif operator == 'sub':\n",
        "    return x - y\n",
        "  elif operator == 'mul':\n",
        "    return x * y\n",
        "  elif operator == 'div':\n",
        "    return x / y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "9CzJY_o_ru1h"
      },
      "outputs": [],
      "source": [
        "def dispatch_dict(op, x, y):\n",
        "  return {\n",
        "    'add': lambda: x + y,\n",
        "    'sub': lambda: x - y,\n",
        "    'mul': lambda: x * y,\n",
        "    'div': lambda: x / y,\n",
        "  }.get(op, lambda: None)()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZJ8CmJUuaB_"
      },
      "source": [
        "**Key Takeaways**\n",
        "+ Python doesn’t have a switch/case statement. But in some cases\n",
        "you can avoid long if-chains with a dictionary-based dispatch\n",
        "table.\n",
        "+ Once again Python’s first-class functions prove to be a powerful\n",
        "tool. But with great power comes great responsibility."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s_U-gfQqvxr7"
      },
      "source": [
        "# 7.4 The Craziest Dict Expression in the West\n",
        "讓我們來看一下以下的字典宣告會產生什麼結果"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DpkCX4OJucds",
        "outputId": "95752e72-d8d4-4e0b-d248-29380a81f881"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{True: 'maybe'}"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "xs = {True: 'yes', 1: 'no', 1.0: 'maybe'}\n",
        "xs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7SUkTxw9y3AV"
      },
      "source": [
        "竟然只剩下一個item，這是因為 python interpreter 將其編譯為以下程式碼\n",
        "```python\n",
        "xs = dict()\n",
        "xs[True] = 'yes'\n",
        "xs[1] = 'no'\n",
        "xs[1.0] = 'maybe'\n",
        "```\n",
        "而三個 key 又是等效的，只會不斷更新 key 對應的數值  \n",
        "  \n",
        "根據 [python document](https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy)\n",
        "> “The Boolean type is a subtype of the integer type, and\n",
        "Boolean values behave like the values 0 and 1, respectively, in almost all contexts, the exception being that\n",
        "when converted to a string, the strings ‘False’ or ‘True’\n",
        "are returned, respectively\n",
        "\n",
        "```python\n",
        "True == 1 == 1.0\n",
        ">>> True\n",
        "```\n",
        "意思是你也能用 True / False 代表 0/1\n",
        "```python\n",
        "['no', 'yes'][True]\n",
        ">>> 'yes'\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uh0ePEME8ILv"
      },
      "source": [
        "python 字典的 key 有兩種比較方式，`__eq__` 和 `__hash__`，只有在兩者**都相同**的情況下才會覆蓋數值"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OOg9cmn4FYnC"
      },
      "source": [
        "只有 `__eq__` 相同，字典視為不同 key 值"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "id": "bTGwZZw4_vXO"
      },
      "outputs": [],
      "source": [
        "class AlwaysEquals:\n",
        "  def __eq__(self, other):\n",
        "    return True\n",
        "  def __hash__(self):\n",
        "    return id(self)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "47Y5NH--BWmN",
        "outputId": "eb218cc0-358d-4de7-a999-a0df5c3281d6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "print(AlwaysEquals() == AlwaysEquals())\n",
        "print(AlwaysEquals() == 42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GnsF6MBYBc0C",
        "outputId": "4fcf100d-e091-45ce-b907-0a2008a9c457"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[140228725248592, 140228725248848, 140228725249040]"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "objects = [AlwaysEquals(),\n",
        "      AlwaysEquals(),\n",
        "      AlwaysEquals()]\n",
        "\n",
        "[hash(obj) for obj in objects]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mKUTi1oEBiae",
        "outputId": "10faa60f-f6b6-43f7-81e4-b52933c7d1af"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{<__main__.AlwaysEquals at 0x7f898b599090>: 'no',\n",
              " <__main__.AlwaysEquals at 0x7f898b599890>: 'yes'}"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "{AlwaysEquals(): 'yes', AlwaysEquals(): 'no'}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ZrlEHVJFRMe"
      },
      "source": [
        "只有 hash 相同，字典視為不同 key 值"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "BgPWNF_DFRg9"
      },
      "outputs": [],
      "source": [
        "class SameHash:\n",
        "  def __hash__(self):\n",
        "    return 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1dsPWQC3FWG6",
        "outputId": "347dc5b6-3288-4311-9875-5aea3d96c1d7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "a = SameHash()\n",
        "b = SameHash()\n",
        "print(a == b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MSL0fO6yF1bW",
        "outputId": "48d48019-62a7-4a21-bee1-d81db34447fa"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{<__main__.SameHash at 0x7f898b593210>: 'a',\n",
              " <__main__.SameHash at 0x7f89989a75d0>: 'b'}"
            ]
          },
          "execution_count": 59,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "{a: 'a', b: 'b'}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u_Sy75YtGHi_"
      },
      "source": [
        "**Key Takeaways**\n",
        "+ Dictionaries treat keys as identical if their \\_\\_eq\\_\\_ comparison\n",
        "result says they’re equal and their hash values are the same.\n",
        "+ Unexpected dictionary key collisions can and will lead to surprising results."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-pJoVekWGaYF"
      },
      "source": [
        "# 7.5 So Many Ways to Merge Dictionaries\n",
        "這章節將講述整合字典的方法  \n",
        "  \n",
        "最後加入的字典級別較高，能覆蓋舊的數值"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "id": "l479kblxGbD6"
      },
      "outputs": [],
      "source": [
        "xs = {'a': 1, 'b': 2}\n",
        "ys = {'b': 3, 'c': 4}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fLmlN92IGnOX",
        "outputId": "8255b2b1-5a2b-4cff-f27f-b3a1b98da57c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'a': 1, 'b': 3, 'c': 4}"
            ]
          },
          "execution_count": 65,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "zs = {}\n",
        "zs.update(xs)\n",
        "zs.update(ys)\n",
        "zs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T7r8EspaH0KY"
      },
      "source": [
        "Python 2 和 Python 3 有內建的整合字典方式，但是只限於整合兩個字典"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CLtQkSdlH0eH",
        "outputId": "d86615c9-ed56-41ea-885c-a111830bf68c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'a': 1, 'b': 3, 'c': 4}"
            ]
          },
          "execution_count": 67,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "zs = dict(xs, **ys)\n",
        "zs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jGHf_4hiIIz3"
      },
      "source": [
        "到了 python 3.5，\\*\\*符號更實用了"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vqqG1wLvINhZ",
        "outputId": "10d587b4-98b2-4f02-9c91-79167ec6ffa2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'a': 1, 'b': 3, 'c': 4}"
            ]
          },
          "execution_count": 68,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "zs = {**xs, **ys}\n",
        "zs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jMmEo8ksIQ5c"
      },
      "source": [
        "**Key Takeaways**\n",
        "+ In Python 3.5 and above you can use the \\*\\*-operator to merge\n",
        "multiple dictionary objects into one with a single expression,\n",
        "overwriting existing keys left-to-right.\n",
        "+ To stay compatible with older versions of Python, you might\n",
        "want to use the built-in dictionary update() method instead."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pp86nmOrKsqY"
      },
      "source": [
        "# 7.6 Dictionary Pretty-Printing\n",
        "預設的字典-字串轉換可讀性很差，順序不一且沒有換行，這導致開發上的困難"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "LhqyxSTiKtxB",
        "outputId": "9dfa0c96-a6c3-4a15-d1b3-a0c81ee6296d"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "\"{'a': 23, 'b': 42, 'c': 12648430}\""
            ]
          },
          "execution_count": 71,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "mapping = {'a': 23, 'b': 42, 'c': 0xc0ffee}\n",
        "str(mapping)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4-AO73sMST5p"
      },
      "source": [
        "json 可以解決此問題，但並不完美\n",
        "+ key 數值只能是 primitive types\n",
        "+ value 不能是 complex data types\n",
        "+ 印出來的 Unicode text 跟原本格式不同"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NTa1KadoIVFR",
        "outputId": "4f78f379-5653-48cd-e7f5-a53f26c44af1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{\n",
            "    \"a\": 23,\n",
            "    \"b\": 42,\n",
            "    \"c\": 12648430\n",
            "}\n"
          ]
        }
      ],
      "source": [
        "import json\n",
        "print(json.dumps(mapping, indent=4, sort_keys=True))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "kyVPNeNcTDOq",
        "outputId": "1d97f47b-877b-422b-e1d2-375a804c2370"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'{\"0\": 1, \"1\": 2}'"
            ]
          },
          "execution_count": 75,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "mapping = {0:1, 1:2}\n",
        "json.dumps(mapping)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "HVDDf88uTNpG"
      },
      "outputs": [],
      "source": [
        "# TypeError: keys must be str, int, float, bool or None, not builtin_function_or_method\n",
        "# json.dumps({all: 'yup'})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {
        "id": "5FYFoWcZUQ_n"
      },
      "outputs": [],
      "source": [
        "# TypeError: Object of type set is not JSON serializable\n",
        "# json.dumps({0: set([1,2,3])})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "4etpd9XAT4-T",
        "outputId": "e4681c85-c1ed-4e7e-ddc5-4def9a3da91e"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'{\"0\": \"\\\\u4f60\\\\u597d\\\\u55ce\"}'"
            ]
          },
          "execution_count": 79,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "json.dumps({0: '你好嗎'})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tl8VcSoSTqva"
      },
      "source": [
        "pprint 能解決以上問題，但在可讀性上沒這麼高"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UE0py_-sTt7R",
        "outputId": "cd56a0db-eadc-4eeb-e09b-7b38f3dd5070"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': 23, 'b': 20, 'c': {1, 2, 3}}\n"
          ]
        }
      ],
      "source": [
        "import pprint\n",
        "\n",
        "mapping = {'a':23,\n",
        "      'b':20,\n",
        "      'c':set([1,2,3])\n",
        "      }\n",
        "\n",
        "pprint.pprint(mapping)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u0QetBCWUigZ"
      },
      "source": [
        "**Key Takeaways**\n",
        "+ The default to-string conversion for dictionary objects in\n",
        "Python can be difficult to read.\n",
        "+ The pprint and json module are “higher-fidelity” options built\n",
        "into the Python standard library.\n",
        "+ Be careful with using json.dumps() and non-primitive keys\n",
        "and values as this will trigger a TypeError."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "CH.7 Dictionary Tricks.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.8.10 64-bit (windows store)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.10"
    },
    "vscode": {
      "interpreter": {
        "hash": "ae784ccfb18bd71bfbb468741712411e6f47c1f5c385b973a4a22dac7f04b551"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}