notebook/Unit1-4-3-Dict.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Dictionaries\n",
    "\n",
    "## 1 Dictionary: Mapping Types\n",
    "The useful data type built into Python is the **dictionary**\n",
    "\n",
    "Unlike sequences, which are indexed by a range of numbers, dictionaries are `indexed by keys`, which can be any immutable type; `strings` and `numbers` can always be keys.\n",
    "\n",
    "In mathematical language, a dictionary represents a `mapping` from `keys` to `values`, so you can also say that each key “maps to” a value. \n",
    "\n",
    "Literals of type dict are enclosed in  <b style=\"color:blue\">curly braces  {}  </b>, \n",
    "\n",
    "Think of a dictionary as a set of <b style=\"color:blue\">key:value</b> pairs.\n",
    "```python\n",
    "'Jan':1\n",
    "1:'Jan'\n",
    "```\n",
    "\n",
    "and each element is written as a `key` followed by <b style=\"color:blue\">a colon :</b> followed by a `value`. \n",
    "For example, the code,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthNumbers= {'Jan':1}\n",
    "print(monthNumbers['Jan'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthString= {1:'Jan'}\n",
    "print(monthString[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The `entries` in a dict `cannot` be accessed with an `index`.**\n",
    "\n",
    "`monthString[1]` unambiguously refers to the entry with the **key 1**: `1:'Jan'` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthNumbers = {'Jan':1, 'Feb':2, 'Mar':3,\n",
    "                 1:'Jan', 2:'Feb', 3:'Mar',}\n",
    "  \n",
    "# The entries in a dict are unordered and cannot be accessed with an index\n",
    "# get value from key\n",
    "\n",
    "print('The Mar is the', format(monthNumbers['Mar']),'month \\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('The third month is ' + monthNumbers[3],'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = monthNumbers['Mar'] - monthNumbers['Jan'] \n",
    "print('Mar and Jan are', dist, 'months apart')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<b style=\"color:blue\">Keys</b> can be values of <b>any immutable type</b>.\n",
    "\n",
    "\n",
    "\n",
    ">Python3.7: The `insertion-order preservation` nature of `dict` objects is now an official part of the Python language spec."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Dictionaries are  <font color=\"blue\">mutable.</font>\n",
    "\n",
    "Like lists, **dictionaries are mutable**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 add an entry to a dictionary \n",
    "\n",
    "We can add an entry by writing\n",
    "\n",
    "```python\n",
    "monthNumbers['Apr'] = 4\n",
    "```\n",
    "**add elements(key:value)** to a dictionary by **assigning a value `6`to an `unused` key `'June'`('June':)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthNumbers['Apr'] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthNumbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3  `change` an entry by writing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthNumbers['Apr'] = '04'\n",
    "monthNumbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Iterate over the entries in a dictionary\n",
    "\n",
    " <b style=\"color:blue\">for</b> statement can be used to `iterate` over the entries in `a dictionary`. \n",
    "\n",
    "```python\n",
    "for <item> in <a dictionary>\n",
    "```\n",
    "\n",
    "However, the `value` assigned to the iteration variable is a <b style=\"color:blue\">key</b>, not a `key/value` pair.\n",
    "\n",
    "For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthNumbers = {'Jan':1, 'Feb':2, 'Mar':3,\n",
    "                1:'Jan', 2:'Feb', 3:'Mar'}\n",
    "keys = []\n",
    "for e in monthNumbers:\n",
    "    print(e)\n",
    "    keys.append(e) # the value s a key， not a key/value pair.\n",
    "\n",
    "print(keys)\n",
    "type(keys)\n",
    "\n",
    "# There is a error in MIT book:'<' not supported between instances of 'int' and 'str'\n",
    "# keys.sort()\n",
    "# print(keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Dictionary view objects\n",
    "\n",
    "The view objects returned by \n",
    "  \n",
    "* **dict.keys()** :reture is a `dict_keys` object, which is an iterator \n",
    "\n",
    "        \n",
    "* **dict.values()** reture is a `dict_values` object, which is an iterator\n",
    "    \n",
    "    \n",
    "* **dict.items()**:reture is a `dict_items` object, which is an iterator that iterates the `key-value` pairs\n",
    "\n",
    "The view objects can be \n",
    "\n",
    "* `iterated` over using <b style=\"color:blue\">for</b> \n",
    "    \n",
    "* `membership` can be `tested` using <b style=\"color:blue\">in</b> \n",
    "\n",
    "*  easily converted into a `list`, using <b style=\"color:blue\">list</b>\n",
    "\n",
    "They provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes.\n",
    "\n",
    "### 4.1 dict.keys() \n",
    "\n",
    "The method **keys** returns an object of type `dict_keys`.\n",
    "\n",
    "* The `order` in which the keys appear in the view is `not defined`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}\n",
    "keys = dishes.keys() # The order in which the keys appear is not defined.\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in keys:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'eggs' in dishes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 dict.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = dishes.values()\n",
    "values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0\n",
    "for val in values:\n",
    "    n += val\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 dict.items()\n",
    "\n",
    "**dict.items()**: Return a new view of the dictionary’s items <strong style=\"color:blue\">(key, value)</strong> pairs  in **tuple** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}\n",
    "items = dishes.items()\n",
    "items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs=[]\n",
    "for (key,value) in dishes.items():\n",
    "    print(key,value)\n",
    "    pairs.append((key,value)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('eggs', 2) in items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs=list(dishes.items())\n",
    "print('(key,value) in monthNumbers.items():')\n",
    "print(pairs)\n",
    "\n",
    "print(pairs[0])\n",
    "\n",
    "print(pairs[0][0],pairs[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 view objects：dynamic and reflect dict changes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}\n",
    "\n",
    "keys = dishes.keys()\n",
    "values = dishes.values()\n",
    "items=dishes.items()\n",
    "\n",
    "print(keys)\n",
    "print(values)\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**change values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes['eggs']=20\n",
    "print(values)\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**add a `key:value` pair**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes['fishes']=8\n",
    "print(keys)\n",
    "print(values)\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**delete items**\n",
    "\n",
    "* del d[k] :remove key `k` from `d`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del dishes['eggs']\n",
    "del dishes['sausage']\n",
    "print(keys)\n",
    "print(values)\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 The dictionary methods \n",
    "\n",
    "As with lists, there are many useful methods associated with dictionaries, including some for removing elements. \n",
    "\n",
    "* `d.keys()`： returns a view of the keys in d.\n",
    "\n",
    "* `d.values()`： returns a view of the values in d.\n",
    "\n",
    "* `d.items()`： return a new view of the dictionary’s items <strong style=\"color:blue\">(key, value)</strong> pairs  in **tuple** \n",
    "\n",
    "* `d[k]` ：returns the item in d with key k. Raises KeyError if k is not in d.\n",
    "\n",
    "*  `d[k] = v`： associates the value v with the key k. If there is already a value associated\n",
    "with k, that value is replaced.\n",
    "\n",
    "* `for k in d` iterates over the keys in d.\n",
    "---\n",
    "* `d.update(d1)`: merge the given dictionary d1 into d. Override the value if key exists, else, add new key-value.\n",
    "\n",
    "* `len(d)`： returns the number of items in d.\n",
    "\n",
    "* `d.pop()`: simultaneously returns the value and deletes the key\n",
    "\n",
    "* `d.has_key()`:\n",
    "\n",
    "* `k in d` ：returns True if key k is in d.\n",
    "\n",
    "* `d.get(k, v)`： returns d[k] if k in d, and v otherwise.\n",
    "\n",
    "* `del d[k]`： removes element with key k from d. Raises KeyError if k is not in d.\n",
    "\n",
    "* `d.clear()`: removes all elements from d\n",
    "\n",
    "* `d.copy()`: return a copy of  d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  5.1 update([other])\n",
    "\n",
    "Update the dictionary with the `key/value` pairs from other, overwriting existing keys. Return None.\n",
    "\n",
    "* `update()` accepts either `another dictionary` object or an `iterable of key/value pairs` (as tuples or other iterables of length two). \n",
    "  \n",
    "* If keyword arguments are specified, the dictionary is then updated with those key/value pairs:\n",
    "\n",
    "The update method changes dicts `in-place`, so any existing keys in the data passed to update will have their old values discarded.\n",
    "\n",
    "You can **merge** one dict into another using the `update` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d={\"red\":11,\"blue\":22}\n",
    "#  update the Dictionary with another dictionary\n",
    "# the existing key :\"red\":\n",
    "# the new key: \"yellow\"\n",
    "d.update({\"red\":111,\"yellow\":33})\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# update the Dictionary with iterable \n",
    "d.update(red=1, blue=2) \n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 pop\n",
    "\n",
    "the `pop` method  simultaneously `returns the value` and deletes the key:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}\n",
    "ret = dishes.pop('eggs') # returns the value simultaneously\n",
    "ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dishes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Dictionary Comprehension \n",
    "\n",
    "Dictionary comprehension is similar to list comprehension.\n",
    "The general form is \n",
    "```python\n",
    "{key: value for id1, id2 in iterable} \n",
    "```\n",
    "The key difference (other than the use of set braces rather than square braces) is that it uses two values to create each element of the dictionary, and allows (but does not require) the iterable to return two values at a time. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r_n={k: v for k, v in (('I', 1), ('II', 2))}\n",
    "r_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "char_n={chr(n): n for n in (65, 66, 66)}\n",
    "char_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}\n",
    "# Double each value in the dictionary\n",
    "double_dict1 = {k:v*2 for (k,v) in dict1.items()}\n",
    "print(double_dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "objects = ['blue', 'apple', 'dog']\n",
    "categories = ['color', 'fruit', 'pet']\n",
    "a_dict = {key: value for key, value in zip(categories, objects)}\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "568px",
    "left": "419px",
    "top": "110.98px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}