Strings_and_Dictionaries.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNKaeNEFim3wWIsIQKY43aN",
      "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/farhadrahimiinfo/Python-Learning/blob/main/Strings_and_Dictionaries.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "datestr = '1402-03-31'\n",
        "year, month, day = datestr.split('-')\n",
        "print (year, month, day)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6cVmpy4mP9nD",
        "outputId": "2b2cefe2-d5bf-4398-d1d7-1d4282b28406"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1402 03 31\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'/'.join([year,month, day])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "zVFuBhojQU12",
        "outputId": "c977c5cd-f535-4049-e5b9-5ddeadf58df6"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1402/03/31'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Yes, we can put unicode characters right in our string literals :)\n",
        "' 👏 '.join([word.upper() for word in words])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "NxpB4EdSQe9J",
        "outputId": "b6e0a66d-a7fd-41ba-f701-0f15f5f9ec30"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'PLUTO 👏 IS 👏 A 👏 PLANET!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "y_aOLVWNQhHr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "hello = \"farhad\\nrahimi\"\n",
        "print(hello)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mn0GXrNFOyH4",
        "outputId": "e2ff7aa7-489c-4ed3-bd60-7bb78252651f"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "farhad\n",
            "rahimi\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-n3ZbVl8Oab5",
        "outputId": "03eef939-6c0b-4780-89c1-8cba41172298"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "x = 'Pluto is a planet'\n",
        "y = \"Pluto is a planet\"\n",
        "x == y"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Pluto's a planet!\")\n",
        "print('My dog is named \"Pluto\"')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JWyNkFRaOiud",
        "outputId": "5e19e240-f19e-4162-c09e-ec0606faeab1"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pluto's a planet!\n",
            "My dog is named \"Pluto\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('it\\'s a car!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "whCvKavrOmv7",
        "outputId": "646919f1-9106-46e7-db17-9b8e3b298055"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "it's a car!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "triplequoted_hello = \"\"\"hello\n",
        "world\"\"\"\n",
        "print(triplequoted_hello)\n",
        "triplequoted_hello == hello"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jv1C7jJiO3LU",
        "outputId": "a2e813a8-b39e-47fe-9f72-e7cefacfd18c"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "world\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"farhad\")\n",
        "print(\"rahimi\")\n",
        "print(\"farhad\", end='')\n",
        "print(\"rahimi\", end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TXoNCteRPBA-",
        "outputId": "4acc9003-5488-48ff-9f3a-030ff490ad3c"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "farhad\n",
            "rahimi\n",
            "farhadrahimi"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planet = 'Pluto'\n",
        "planet[0]"
      ],
      "metadata": {
        "id": "DichNgLwO_8A",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "096c9d5a-ccc5-4abb-a319-e8c5f0280147"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'P'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planet[3:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "nw3TaJ62PNgG",
        "outputId": "820c0f61-4ef4-40b7-c992-8e206e52cfa5"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'to'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planet[-3:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "5pqXJsMxPPkB",
        "outputId": "f51504e1-311a-4595-8f86-634567646d9e"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'uto'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(planet)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bDLUTIraPWc4",
        "outputId": "44c007c7-3634-46fd-a9c0-3d598eba1494"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Yes, we can even loop over them\n",
        "[char+'! ' for char in planet]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TuUGYkqKPa-f",
        "outputId": "2f562d20-48b3-4cdf-b05e-f5b60d61e5d1"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['P! ', 'l! ', 'u! ', 't! ', 'o! ']"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "claim = \"Pluto is a planet!\"\n",
        "claim.upper()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "nqlQGshoPhMc",
        "outputId": "56b72192-7cb5-483c-ecc2-ab5243c10739"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'PLUTO IS A PLANET!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "claim.lower()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "3l1DrCNTPlxC",
        "outputId": "affb1bc9-f785-413a-ff12-e760021c43bf"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'pluto is a planet!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Searching for the first index of a substring\n",
        "claim.index('plan')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ebehXkQPoog",
        "outputId": "6f08d055-9601-4cdc-f213-4cc670d1a7a2"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "claim.startswith(planet)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_mqT9WvPt0_",
        "outputId": "4a98be3f-d091-482f-a37b-562bd6c5d308"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "claim.endswith('planet')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ID7H1lW2PyoW",
        "outputId": "f3dc35de-740d-4e2d-943a-624fc57bc384"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "words = claim.split()\n",
        "words\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ifyGLZGRP5fa",
        "outputId": "db8093db-2eb0-4ff8-886a-a2dfd2e61d20"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Pluto', 'is', 'a', 'planet!']"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planet + ', we miss you.'\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "UxH1HVDOQQrM",
        "outputId": "7a2c6fa0-597a-42fb-c2ce-bc8f83386902"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Pluto, we miss you.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "position=15\n",
        "planet + \", you'll always be the \" + str(position) + \"th planet to me.\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "DaKY2yB7Qqr1",
        "outputId": "218aaa3f-4f2f-4468-ad82-740685f52c7e"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Pluto, you'll always be the 15th planet to me.\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"{}, you'll always be the {}th planet to me.\".format(planet, position)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "ehBuWoWGQxql",
        "outputId": "53997d27-da37-4ef0-bfa4-52f94af4bb05"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Pluto, you'll always be the 15th planet to me.\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pluto_mass = 1.303 * 10**22\n",
        "earth_mass = 5.9722 * 10**24\n",
        "population = 52910390\n",
        "#         2 decimal points   3 decimal points, format as percent     separate with commas\n",
        "\"{} weighs about {:.2} kilograms ({:.3%} of Earth's mass). It is home to {:,} Plutonians.\".format(\n",
        "    planet, pluto_mass, pluto_mass / earth_mass, population,\n",
        ")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "CjOwnr5cQ6yf",
        "outputId": "80f8c9e8-e670-4281-94d9-a272387001cf"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Pluto weighs about 1.3e+22 kilograms (0.218% of Earth's mass). It is home to 52,910,390 Plutonians.\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Referring to format() arguments by index, starting from 0\n",
        "s = \"\"\"Pluto's a {0}.\n",
        "No, it's a {1}.\n",
        "{0}!\n",
        "{1}!\"\"\".format('planet', 'dwarf planet')\n",
        "print(s)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ttf_05W4RCzB",
        "outputId": "300cbfd0-5716-43b2-e791-10f2ae852a09"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pluto's a planet.\n",
            "No, it's a dwarf planet.\n",
            "planet!\n",
            "dwarf planet!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Dictionaries\n",
        "#Dictionaries are a built-in Python data structure for mapping keys to values.\n",
        "\n",
        "numbers = {'one':1, 'two':2, 'three':3}\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SfG5FpUQRH-4",
        "outputId": "b52c607c-3660-48bc-9ad4-48b0ee643d64"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'one': 1, 'two': 2, 'three': 3}"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers['one']\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tBRMvXE9RUGB",
        "outputId": "56160db2-778c-4b45-e6c6-d8ed442bb690"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers['eleven'] = 11\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vc5aPDVDRZZb",
        "outputId": "49192063-be6c-4f82-b7bd-2ccea1cc5727"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'one': 1, 'two': 2, 'three': 3, 'eleven': 11}"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers['one'] = 'Pluto'\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sWTFxRj8RhHA",
        "outputId": "412bf8ff-2a56-40ab-e46f-5139eae02c5d"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'one': 'Pluto', 'two': 2, 'three': 3, 'eleven': 11}"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
        "planet_to_initial = {planet: planet[0] for planet in planets}\n",
        "planet_to_initial"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BnP_QMsLRlaQ",
        "outputId": "a574e1cf-6fa7-41dd-8d15-2295801dc1f8"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Mercury': 'M',\n",
              " 'Venus': 'V',\n",
              " 'Earth': 'E',\n",
              " 'Mars': 'M',\n",
              " 'Jupiter': 'J',\n",
              " 'Saturn': 'S',\n",
              " 'Uranus': 'U',\n",
              " 'Neptune': 'N'}"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#The in operator tells us whether something is a key in the dictionary\n",
        "'Saturn' in planet_to_initial\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3P3u-LH_RwU2",
        "outputId": "2eb97c83-8b52-44b2-ac6d-f4ecdc858f3f"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'Betelgeuse' in planet_to_initial\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AX76D5-dR2MX",
        "outputId": "050d9ea1-1866-4f3a-ad64-ef4cb529fb91"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#A for loop over a dictionary will loop over its keys\n",
        "\n",
        "for k in numbers:\n",
        "    print(\"{} = {}\".format(k, numbers[k]))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kleH9CjPR5zB",
        "outputId": "89529531-c778-4def-932b-0866dffdff6a"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "one = Pluto\n",
            "two = 2\n",
            "three = 3\n",
            "eleven = 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#We can access a collection of all the keys or all the values with dict.keys() and dict.values(), respectively.\n",
        "# Get all the initials, sort them alphabetically, and put them in a space-separated string.\n",
        "' '.join(sorted(planet_to_initial.values()))\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "ia9D0TKQSJPH",
        "outputId": "d6dca7c2-d5b4-40a9-ad7c-69bd00034fab"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'E J M M N S U V'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for planet, initial in planet_to_initial.items():\n",
        "    print(\"{} begins with \\\"{}\\\"\".format(planet.rjust(10), initial))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_qIOLhFKSYuW",
        "outputId": "7a3cd51e-7325-4eca-8ce6-391c1439dc06"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   Mercury begins with \"M\"\n",
            "     Venus begins with \"V\"\n",
            "     Earth begins with \"E\"\n",
            "      Mars begins with \"M\"\n",
            "   Jupiter begins with \"J\"\n",
            "    Saturn begins with \"S\"\n",
            "    Uranus begins with \"U\"\n",
            "   Neptune begins with \"N\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "help(dict)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WFp7RiIiSjxW",
        "outputId": "7fa848bc-8dc8-4c23-eb01-02d8c8d44956"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on class dict in module builtins:\n",
            "\n",
            "class dict(object)\n",
            " |  dict() -> new empty dictionary\n",
            " |  dict(mapping) -> new dictionary initialized from a mapping object's\n",
            " |      (key, value) pairs\n",
            " |  dict(iterable) -> new dictionary initialized as if via:\n",
            " |      d = {}\n",
            " |      for k, v in iterable:\n",
            " |          d[k] = v\n",
            " |  dict(**kwargs) -> new dictionary initialized with the name=value pairs\n",
            " |      in the keyword argument list.  For example:  dict(one=1, two=2)\n",
            " |  \n",
            " |  Built-in subclasses:\n",
            " |      StgDict\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __contains__(self, key, /)\n",
            " |      True if the dictionary has the specified key, else False.\n",
            " |  \n",
            " |  __delitem__(self, key, /)\n",
            " |      Delete self[key].\n",
            " |  \n",
            " |  __eq__(self, value, /)\n",
            " |      Return self==value.\n",
            " |  \n",
            " |  __ge__(self, value, /)\n",
            " |      Return self>=value.\n",
            " |  \n",
            " |  __getattribute__(self, name, /)\n",
            " |      Return getattr(self, name).\n",
            " |  \n",
            " |  __getitem__(...)\n",
            " |      x.__getitem__(y) <==> x[y]\n",
            " |  \n",
            " |  __gt__(self, value, /)\n",
            " |      Return self>value.\n",
            " |  \n",
            " |  __init__(self, /, *args, **kwargs)\n",
            " |      Initialize self.  See help(type(self)) for accurate signature.\n",
            " |  \n",
            " |  __ior__(self, value, /)\n",
            " |      Return self|=value.\n",
            " |  \n",
            " |  __iter__(self, /)\n",
            " |      Implement iter(self).\n",
            " |  \n",
            " |  __le__(self, value, /)\n",
            " |      Return self<=value.\n",
            " |  \n",
            " |  __len__(self, /)\n",
            " |      Return len(self).\n",
            " |  \n",
            " |  __lt__(self, value, /)\n",
            " |      Return self<value.\n",
            " |  \n",
            " |  __ne__(self, value, /)\n",
            " |      Return self!=value.\n",
            " |  \n",
            " |  __or__(self, value, /)\n",
            " |      Return self|value.\n",
            " |  \n",
            " |  __repr__(self, /)\n",
            " |      Return repr(self).\n",
            " |  \n",
            " |  __reversed__(self, /)\n",
            " |      Return a reverse iterator over the dict keys.\n",
            " |  \n",
            " |  __ror__(self, value, /)\n",
            " |      Return value|self.\n",
            " |  \n",
            " |  __setitem__(self, key, value, /)\n",
            " |      Set self[key] to value.\n",
            " |  \n",
            " |  __sizeof__(...)\n",
            " |      D.__sizeof__() -> size of D in memory, in bytes\n",
            " |  \n",
            " |  clear(...)\n",
            " |      D.clear() -> None.  Remove all items from D.\n",
            " |  \n",
            " |  copy(...)\n",
            " |      D.copy() -> a shallow copy of D\n",
            " |  \n",
            " |  get(self, key, default=None, /)\n",
            " |      Return the value for key if key is in the dictionary, else default.\n",
            " |  \n",
            " |  items(...)\n",
            " |      D.items() -> a set-like object providing a view on D's items\n",
            " |  \n",
            " |  keys(...)\n",
            " |      D.keys() -> a set-like object providing a view on D's keys\n",
            " |  \n",
            " |  pop(...)\n",
            " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
            " |      \n",
            " |      If the key is not found, return the default if given; otherwise,\n",
            " |      raise a KeyError.\n",
            " |  \n",
            " |  popitem(self, /)\n",
            " |      Remove and return a (key, value) pair as a 2-tuple.\n",
            " |      \n",
            " |      Pairs are returned in LIFO (last-in, first-out) order.\n",
            " |      Raises KeyError if the dict is empty.\n",
            " |  \n",
            " |  setdefault(self, key, default=None, /)\n",
            " |      Insert key with a value of default if key is not in the dictionary.\n",
            " |      \n",
            " |      Return the value for key if key is in the dictionary, else default.\n",
            " |  \n",
            " |  update(...)\n",
            " |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
            " |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
            " |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
            " |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
            " |  \n",
            " |  values(...)\n",
            " |      D.values() -> an object providing a view on D's values\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Class methods defined here:\n",
            " |  \n",
            " |  __class_getitem__(...) from builtins.type\n",
            " |      See PEP 585\n",
            " |  \n",
            " |  fromkeys(iterable, value=None, /) from builtins.type\n",
            " |      Create a new dictionary with keys from iterable and values set to value.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Static methods defined here:\n",
            " |  \n",
            " |  __new__(*args, **kwargs) from builtins.type\n",
            " |      Create and return a new object.  See help(type) for accurate signature.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data and other attributes defined here:\n",
            " |  \n",
            " |  __hash__ = None\n",
            "\n"
          ]
        }
      ]
    }
  ]
}