activity_printing_dictionaries.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Printing Python Dictionaries",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [
        "QfXYIW8Xo7Kz"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZCqd9Db-8UBW",
        "colab_type": "text"
      },
      "source": [
        "<table border=\"0\" align=\"left\" width=\"700\" height=\"144\">\n",
        "<tbody>\n",
        "<tr>\n",
        "<td width=\"120\"><img width=\"100\" src=\"https://static1.squarespace.com/static/5992c2c7a803bb8283297efe/t/59c803110abd04d34ca9a1f0/1530629279239/\" /></td>\n",
        "<td style=\"width: 600px; height: 67px;\">\n",
        "<h1 style=\"text-align: left;\">Printing Python Dictionaries</h1>\n",
        "<p><a href=\"https://colab.research.google.com/github/KenzieAcademy/python-notebooks/blob/master/activity_printing_dictionaries.ipynb\"> <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\" align=\"left\" width=\"188\" height=\"32\" /> </a></p>\n",
        "</td>\n",
        "</tr>\n",
        "</tbody>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9kENItSOiCLo",
        "colab_type": "text"
      },
      "source": [
        "In this activity, you will practice four different ways of printing the contents\n",
        "of a python dictionary. Remember from the Zen of Python (`import this`) that *readability counts*. In order to communicate results effectively, results must be readable."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9o8nmLGWi1Gn",
        "colab_type": "text"
      },
      "source": [
        "A Python dictionary is an associative mapping of keys and values. Our goal is to print the key/value pairs of a dictionary in ways that are \"non-confusing\" to humans. Let us start by creating a sample dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lGeurspHjVeA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# A dictionary of warriors and their scores\n",
        "kung_fu_scores = {'Tigress': 95.1, 'Mantis': 79.3, 'Monkey': 80.0, 'Crane': 88.8, 'Serpent': 74.4, 'Dragon': 100.0}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CeSoQTUtkvpY",
        "colab_type": "text"
      },
      "source": [
        "The simplest way to print this dictionary is with the `print()` function. Let's try it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ujdvBKLdk5Z6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(kung_fu_scores)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MqChkie0lB7z",
        "colab_type": "text"
      },
      "source": [
        "But this form is not very readable in horizontal form, especially if you are trying to visually compare values (or keys) with each other. This type of data is much easier on the eyes when printed in vertical format, or \"line-by-line\". Let's try a different way:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5d2Cbb27loCj",
        "colab_type": "text"
      },
      "source": [
        "## Problem 1: Line-by-line, using a `for` loop & `dict.items()`\n",
        "The built-in method `dict.items()` returns an iterable 'view object' that generates 2-tuples. Each 2-tuple contains a (key, value) pair from the dictionary. We can use a for-loop to iterate over each pair item in the dictionary. Change each `???` in the for-loop below to achieve output like this when the cell is run:\n",
        ">```\n",
        "Tigress  :  95.1\n",
        "Mantis  :  79.3\n",
        "Monkey  :  80.0\n",
        "Crane  :  88.8\n",
        "Serpent  :  74.4\n",
        "Dragon  :  100.0\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yG2tgGP7mUah",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for ???, ??? in ???:\n",
        "    print(???, ' : ', ???)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BoASQtOSm_IL",
        "colab_type": "text"
      },
      "source": [
        "## Problem 2: Line-by-line, iterating over keys only\n",
        "You can also iterate over just the keys of a dictionary, one by one. Then, for each key, access its value and print each on a separate line. The default iteration of a dictionary is its keys, so you don't need to explicitly use the `dict.keys()` method. Your output should be the same as the cell above."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nBdf6_CBnShR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# iterate over just the keys, print each key and its corresponding value\n",
        "# -- your code here --"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i9dxVOnQn2s0",
        "colab_type": "text"
      },
      "source": [
        "## Problem 3: Line-by-line, using a list comprehension\n",
        "You can print the dictionary using one line of list comprehension code, along with the `dict.items()` method. The output might look something like this\n",
        ">```\n",
        "Tigress  :  95.1\n",
        "Mantis  :  79.3\n",
        "Monkey  :  80.0\n",
        "Crane  :  88.8\n",
        "Serpent  :  74.4\n",
        "Dragon  :  100.0\n",
        "[None, None, None, None, None, None]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4KiOeqIsn9mn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# One-liner list comprehension, using dict.items()\n",
        "# -- your code here --"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xf0sPOZovQSP",
        "colab_type": "text"
      },
      "source": [
        "# Problem 4: line by line using json.dumps()\n",
        "The `json` standard library (included with python) provides a function `json.dumps()`. This function will *serialize* an object into a JSON string. We can pass a dictionary into `json.dumps()` to get a return string that contains each key-value pair from the dictionary on a separate line. Then, we can just print that string. When calling the `json.dumps()` function, you can specify an additional parameter of `indent=4`. Your output should look like this:\n",
        ">```\n",
        "{\n",
        "    \"Tigress\": 95.1,\n",
        "    \"Mantis\": 79.3,\n",
        "    \"Monkey\": 80.0,\n",
        "    \"Crane\": 88.8,\n",
        "    \"Serpent\": 74.4,\n",
        "    \"Dragon\": 100.0\n",
        "}\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7R9Kg5PBwAji",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# print the dictionary using the json.dumps() method\n",
        "import ???\n",
        "print(???)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qnavT6CqyP6D",
        "colab_type": "text"
      },
      "source": [
        "# Nested Dictionaries\n",
        "Sometimes you will find dictionaries nested inside other dictionaries. It can be a real pain to inspect the data in these nested structures. But never fear, `json.dumps()` to the rescue again!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JtwvXrBWyvtB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import json\n",
        "# nested dictionary containing scoring components\n",
        "kung_fu_scores = {\n",
        "    'Tigress': {\"staff\": 8.6, \"sword\": 6.0, \"shuriken\": 9.5}, \n",
        "    'Mantis': {\"staff\": 2.5, \"sword\": 2.2, \"shuriken\": 7.4}, \n",
        "    'Monkey': {\"staff\": 8.6, \"sword\": 6.0, \"shuriken\": 9.5}, \n",
        "    'Crane': {\"staff\": 8.6, \"sword\": 5.0, \"shuriken\": 3.5},\n",
        "    'Serpent': {\"staff\": 9.6, \"sword\": 2.0, \"shuriken\": 1.5}, \n",
        "    'Dragon': {\"staff\": 100.0, \"sword\": 100.0, \"shuriken\": 99.9}\n",
        "}\n",
        "print(json.dumps(kung_fu_scores, indent=4))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jc-k3qMK1zIc",
        "colab_type": "text"
      },
      "source": [
        "Don't you think the `json.dumps()` code above is easier than doing it this way (below)?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5l5lNCWk1510",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Iterate over key/value pairs of parent dictionary\n",
        "for key, value in kung_fu_scores.items():\n",
        "    print(key, '--')\n",
        "    # Again iterate over the nested dictionary\n",
        "    for skill, score in value.items():\n",
        "        print('\\t', skill, ' : ', score)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lkyXgNEN2SMx",
        "colab_type": "text"
      },
      "source": [
        "# Conclusion\n",
        "Making your output informative, readable and good-looking is part of your new craft. Learn it well!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QfXYIW8Xo7Kz",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# Solutions\n",
        "No peeking until you are done!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I8WNTxFspD8I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Problem 1:\n",
        "for key, value in kung_fu_scores.items():\n",
        "    print(key, ' : ', value)\n",
        "\n",
        "# Problem 2:\n",
        "for name in kung_fu_scores:\n",
        "    print(name, ' : ', kung_fu_scores[name])\n",
        "\n",
        "# Problem 3:\n",
        "[print(key, ' : ', value) for key, value in kung_fu_scores.items()]\n",
        "\n",
        "# Problem 4:\n",
        "import json\n",
        "print(json.dumps(kung_fu_scores, indent=4))"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}