005_Python_Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Datatypes** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/02_Python_Datatypes)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Dictionary\n",
    "\n",
    "In this class, you'll learn everything about Python dictionaries; how they are created, accessing, adding, removing elements from them and various built-in methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Dictionary in Python?\n",
    "\n",
    "Python dictionary is an unordered collection of items. Each item of a dictionary has a **`key/value`** pair. \n",
    "\n",
    "Dictionaries are optimized to retrieve values when the key is known.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/d0.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "**Example:**\n",
    "\n",
    "```python\n",
    ">>> dict = { }  #empty dictionary\n",
    ">>> dict = {1:'Python',2:'Java',3:'C++'}\n",
    "```\n",
    "\n",
    "* **Dictionary is mutable** i.e., value can be updated.\n",
    "\n",
    "* Key must be unique and immutable. Value is accessed by key. Value can be updated while key cannot be changed. \n",
    "\n",
    "* Dictionary is known as Associative array since the Key works as Index and they are decided by the user."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Python Dictionary\n",
    "\n",
    "Creating a dictionary is as simple as placing items inside curly braces **`{}`** separated by commas or the **[dict()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/015_Python_dict%28%29.ipynb)** built-in function.\n",
    "\n",
    "An item has a **`key`** and a corresponding **`value`** that is expressed as a pair {**key: value**}.\n",
    "\n",
    "The **`key`** and the **`value`** is separated by a colon **`:`**. Items are separated from each other by a comma **`,`**.\n",
    "\n",
    "While the values can be of any data type and can repeat, keys must be of immutable type (**[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)**, **[number](https://github.com/milaan9/02_Python_Datatypes/blob/main/001_Python_Numbers.ipynb)** or **[tuple](https://github.com/milaan9/02_Python_Datatypes/blob/main/004_Python_Tuple.ipynb)** with immutable elements) and must be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:34.175014Z",
     "start_time": "2021-10-03T15:24:34.150602Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Example: empty dictionary\n",
    "\n",
    "my_dict = {}\n",
    "\n",
    "# dictionary with integer keys\n",
    "my_dict = {1: 'apple', 2: 'ball'}\n",
    "\n",
    "# dictionary with mixed keys\n",
    "my_dict = {'name': 'John', 1: [2, 4, 3]}\n",
    "\n",
    "# using dict()\n",
    "my_dict = dict({1:'apple', 2:'ball'})\n",
    "\n",
    "# from sequence having each item as a pair\n",
    "my_dict = dict([(1,'apple'), (2,'ball')])\n",
    "print(len(my_dict)) # 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see from above, we can also create a dictionary using the built-in **`dict()`** function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Elements from Dictionary\n",
    "\n",
    "While indexing is used with other data types to access values, a dictionary uses **`keys`**. Keys can be used either inside square brackets **`[]`** or with the **`get()`** method.\n",
    "\n",
    "If we use the square brackets **`[]`**, **`KeyError`** is raised in case a key is not found in the dictionary. On the other hand, the **`get()`** method returns **`None`** if the key is not found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:34.899634Z",
     "start_time": "2021-10-03T15:24:34.177947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack\n",
      "26\n",
      "None\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'address'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-be29909c5d28>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_dict\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'address'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# Output None\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_dict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'address'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m      \u001b[1;31m# KeyError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'address'"
     ]
    }
   ],
   "source": [
    "# Example: get vs [] for retrieving elements\n",
    "\n",
    "my_dict = {'name': 'Jack', 'age': 26}\n",
    "\n",
    "print(my_dict['name'])         # Output: Jack\n",
    "\n",
    "print(my_dict.get('age'))      # Output: 26\n",
    "\n",
    "# Trying to access keys which doesn't exist throws error\n",
    "print(my_dict.get('address'))  # Output None\n",
    "\n",
    "print(my_dict['address'])      # KeyError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:45.041411Z",
     "start_time": "2021-10-03T15:24:45.034578Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "Gods language\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++','c': 'Gods language'}\n",
    "print(dict[1])\n",
    "print(dict['c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* If we attempt to access a data item with a key, which is not a part of the dictionary, we get an error as follows −"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:45.980882Z",
     "start_time": "2021-10-03T15:24:45.928146Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "4",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-6fbe8e7159c1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mdict\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;34m'Python'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;34m'Java'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;34m'C++'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'c'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'Gods language'\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 4"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++','c': 'Gods language'}\n",
    "print(dict[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* iterate all elemnet using for loop for **`keys()`** method, **`keys()`** method return list of all keys in dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:46.489676Z",
     "start_time": "2021-10-03T15:24:46.473079Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys([1, 2, 3, 'c'])\n",
      "Python\n",
      "Java\n",
      "C++\n",
      "Gods language\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++','c': 'Gods language'}\n",
    "print(dict.keys())\n",
    "for x in dict.keys():\n",
    "    print(dict[x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing and Adding Dictionary elements\n",
    "\n",
    "Dictionaries are mutable. We can add new items or change the value of existing items using an assignment operator.\n",
    "\n",
    "If the key is already present, then the existing value gets updated. In case the key is not present, a new **`(key: value)`** pair is added to the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:47.367623Z",
     "start_time": "2021-10-03T15:24:47.345164Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Jack', 'age': 27}\n",
      "{'name': 'Jack', 'age': 27, 'address': 'Downtown'}\n"
     ]
    }
   ],
   "source": [
    "# Changing and adding Dictionary Elements\n",
    "my_dict = {'name': 'Jack', 'age': 26}\n",
    "\n",
    "\n",
    "my_dict['age'] = 27   # update value\n",
    "print(my_dict)        # Output: {'age': 27, 'name': 'Jack'}\n",
    "\n",
    "my_dict['address'] = 'Downtown'  # add item\n",
    "print(my_dict)        # Output: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:47.707473Z",
     "start_time": "2021-10-03T15:24:47.698687Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python', 2: 'Java', 3: 'C#', 4: 'PHP'}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++'}\n",
    "dict[3]=\"C#\"\n",
    "dict[4]=\"PHP\"   # insert new value\n",
    "print(dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing elements from Dictionary\n",
    "\n",
    "We can remove a particular item in a dictionary by using the **`pop()`** method. This method removes an item with the provided **`key`** and returns the **`value`**.\n",
    "\n",
    "The **`popitem()`** method can be used to remove and return an arbitrary **`(key, value)`** item pair from the dictionary. All the items can be removed at once, using the **`clear()`** method.\n",
    "\n",
    "We can also use the **`del`** keyword to remove individual items or the entire dictionary itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:48.339320Z",
     "start_time": "2021-10-03T15:24:48.319789Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "{1: 1, 2: 4, 3: 9, 5: 25}\n",
      "(5, 25)\n",
      "{1: 1, 2: 4, 3: 9}\n",
      "{}\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'squares' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-93a12a4c44ae>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0msquares\u001b[0m             \u001b[1;31m# delete the dictionary itself\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msquares\u001b[0m\u001b[1;33m)\u001b[0m          \u001b[1;31m# Throws Error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'squares' is not defined"
     ]
    }
   ],
   "source": [
    "# Example: Removing elements from a dictionary\n",
    "\n",
    "\n",
    "squares = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}   # create a dictionary\n",
    "\n",
    "# remove a particular item, returns its value\n",
    "print(squares.pop(4))    # Output: 16\n",
    "\n",
    "print(squares)           # Output: {1: 1, 2: 4, 3: 9, 5: 25}\n",
    "\n",
    "# remove an arbitrary item, return (key,value)\n",
    "print(squares.popitem()) # Output: (5, 25)\n",
    "\n",
    "print(squares)           # Output: {1: 1, 2: 4, 3: 9}\n",
    "\n",
    "squares.clear()          # remove all items\n",
    "print(squares)           # Output: {}\n",
    "\n",
    "del squares             # delete the dictionary itself\n",
    "print(squares)          # Throws Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:48.676242Z",
     "start_time": "2021-10-03T15:24:48.649873Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python', 2: 'Java', 4: 'PHP'}\n",
      "dict :  {}\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'type' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-abb116263217>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mdict\u001b[0m      \u001b[1;31m# delete entire dictionary\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'type' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "del dict[3]   # remove entry with key 'Name'\n",
    "print(dict)\n",
    "\n",
    "dict.clear()  # remove all entries in dict\n",
    "print(\"dict : \",dict)\n",
    "\n",
    "del dict      # delete entire dictionary\n",
    "print(dict[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary Built-in Dictionary Functions\n",
    "\n",
    "Built-in functions like **`all()`**, **`any()`**, **`len()`**, **`cmp()`**, **`sorted()`**, **`str()`**, **`typ()`**, etc. are commonly used with dictionaries to perform different tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Function | Description |\n",
    "|:----| :--- |\n",
    "| **[all()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/003_Python_all%28%29.ipynb)** | Returns **`True`** if all keys of the dictionary are true (or if the dictionary is empty). | \n",
    "| **[any()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/002_Python_any%28%29.ipynb)** | Returns **`True`** if any key of the dictionary is true. If the dictionary is empty, return **`False`**. | \n",
    "| **[len()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/040_Python_len%28%29.ipynb)** | Returns the length (the number of items) in the dictionary. | \n",
    "| **cmp()** | Compares items of two dictionaries. (Not available in Python 3). | \n",
    "| **[sorted()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/060_Python_sorted%28%29.ipynb)** | Returns a new sorted list of keys in the dictionary. | \n",
    "| **[str()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/061_Python_str%28%29.ipynb)** | Produces a printable string representation of a dictionary. | \n",
    "| **[type()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/064_Python_type%28%29.ipynb)** | Returns the type of the passed variable. If passed variable is dictionary,then it would return a dictionary type. | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some examples that use built-in functions to work with a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:49.930164Z",
     "start_time": "2021-10-03T15:24:49.912592Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "6\n",
      "[0, 1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# Example: Dictionary Built-in Functions\n",
    "\n",
    "squares = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}\n",
    "\n",
    "print(all(squares))     # Output: False\n",
    "\n",
    "print(any(squares))     # Output: True\n",
    "\n",
    "print(len(squares))     # Output: 6\n",
    "\n",
    "print(sorted(squares))  # Output: [0, 1, 3, 5, 7, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `all(dict)` - The `all()` function returns True when all elements in the given iterable are true. If not, it returns False.\n",
    "\n",
    "In case of dictionaries, if all keys (not values) are true or the dictionary is empty, **`all()`** returns **`True`**. Else, it returns **`false`** for all other cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:50.637213Z",
     "start_time": "2021-10-03T15:24:50.623543Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example 1: How all() works with Python dictionaries?\n",
    "# In case of dictionaries, if all keys (not values) are true or the dictionary is empty, \n",
    "# all() returns True. Else, it returns false for all other cases..\n",
    "\n",
    "s = {0: 'False', 1: 'False'}\n",
    "print(all(s))\n",
    "\n",
    "s = {1: 'True', 2: 'True'}\n",
    "print(all(s))\n",
    "\n",
    "s = {1: 'True', False: 0}\n",
    "print(all(s))\n",
    "\n",
    "s = {}\n",
    "print(all(s))\n",
    "\n",
    "# 0 is False\n",
    "# '0' is True\n",
    "s = {'0': 'True'}\n",
    "print(all(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `any(dict)` - The `any()` function returns True if any element of an iterable is True. If not, any() returns False.\n",
    "\n",
    "In the case of dictionaries, if all keys (not values) are false or the dictionary is empty, `any()` returns `False`. If at least one key is true, `any()` returns `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:51.145031Z",
     "start_time": "2021-10-03T15:24:51.131363Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example 1: How any() works with Python dictionaries?\n",
    "\n",
    "d = {0: 'False'}             # 0 is False\n",
    "print(any(d))\n",
    "\n",
    "d = {0: 'False', 1: 'True'}  # 1 is True\n",
    "print(any(d))\n",
    "\n",
    "d = {0: 'False', False: 0}   # 0 and False are false\n",
    "print(any(d))\n",
    "\n",
    "d = {}                       # iterable is empty\n",
    "print(any(d))\n",
    "\n",
    "# 0 is False\n",
    "# '0' is True\n",
    "d = {'0': 'False'}\n",
    "print(any(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`len(dict)`** - The `len()` function gives the total length of the dictionary. This would be equal to the number of items in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:51.557638Z",
     "start_time": "2021-10-03T15:24:51.544944Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "print(len(dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`sorted(dict)`** - The `sorted()` function sorts the elements of a given iterable in a specific order (either **ascending** or **descending**) and returns the sorted iterable as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:52.002957Z",
     "start_time": "2021-10-03T15:24:51.992215Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'e', 'i', 'o', 'u']\n",
      "['u', 'o', 'i', 'e', 'a']\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "py_dict = {'e': 1, 'a': 2, 'u': 3, 'o': 4, 'i': 5}\n",
    "print(sorted(py_dict))\n",
    "print(sorted(py_dict, reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`str(dict)`** - The `str()` function produces a printable string representation of a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:52.557653Z",
     "start_time": "2021-10-03T15:24:52.545940Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python', 2: 'Java', 3: 'C++', 4: 'PHP'}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "print(str(dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`type()`** - The `type()` function returns the type of the passed variable. If passed variable is dictionary then it would return a dictionary type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:52.896528Z",
     "start_time": "2021-10-03T15:24:52.889694Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "print(type(dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Dictionary Methods\n",
    "\n",
    "Methods that are available with a dictionary are tabulated below. Some of them have already been used in the above examples.\n",
    "\n",
    "| Method | Description |\n",
    "|:----| :--- |\n",
    "| **[clear()](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/001_Python_Dictionary_clear%28%29.ipynb)** | Removes all items from the dictionary. | \n",
    "| **[copy()](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/002_Python_Dictionary_copy%28%29.ipynb)** | Returns a shallow copy of the dictionary. | \n",
    "| **[fromkeys(seq[, v])](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/003_Python_Dictionary_fromkeys%28%29.ipynb)** | Returns a new dictionary with keys from **`seq`** and value equal to **`v`** (defaults to **`None`**). | \n",
    "| **[get(key[,d])](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/004_Python_Dictionary_get%28%29.ipynb)** | Returns the value of the **`key`**. If the **`key`** does not exist, returns **`d`** (defaults to **`None`**). | \n",
    "| **[items()](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/005_Python_Dictionary_items%28%29.ipynb)** | Return a new object of the dictionary's items in **`(key, value)`** format. | \n",
    "| **[keys()](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/006_Python_Dictionary_keys%28%29.ipynb)** | Returns a new object of the dictionary's keys. | \n",
    "| **[pop(key[,d])](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/007_Python_Dictionary_pop%28%29.ipynb)** | Removes the item with the **`key`** and returns its value or **`d`** if **`key`** is not found. If **`d`** is not provided and the **`key`** is not found, it raises **`KeyError`**. | \n",
    "| **[popitem()](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/008_Python_Dictionary_popitem%28%29.ipynb)** | Removes and returns an arbitrary item **`(key, value)`**. Raises **`KeyError`** if the dictionary is empty. | \n",
    "| **[setdefault(key[,d])](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/009_Python_Dictionary_setdefault%28%29.ipynb)** | Returns the corresponding value if the **`key`** is in the dictionary. If not, inserts the **`key`** with a value of **`d`** and returns **`d`** (defaults to **`None`**). | \n",
    "| **[update([other])](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/010_Python_Dictionary_update%28%29.ipynb)** | Updates the dictionary with the key/value pairs from **`other`**, overwriting existing keys. |  \n",
    "| **[values()](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/011_Python_Dictionary_values%28%29.ipynb)** | Returns a new object of the dictionary's values. | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are a few example use cases of these methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:53.793026Z",
     "start_time": "2021-10-03T15:24:53.784240Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Math': 0, 'English': 0, 'Science': 0}\n",
      "('Math', 0)\n",
      "('English', 0)\n",
      "('Science', 0)\n",
      "['English', 'Math', 'Science']\n"
     ]
    }
   ],
   "source": [
    "# Example: Dictionary Methods\n",
    "\n",
    "marks = {}.fromkeys(['Math', 'English', 'Science'], 0)\n",
    "print(marks)                        # Output: {'English': 0, 'Math': 0, 'Science': 0}\n",
    "\n",
    "for item in marks.items():\n",
    "    print(item)\n",
    "\n",
    "print(list(sorted(marks.keys())))   # Output: ['English', 'Math', 'Science']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`clear()`** - The method `clear()` removes all items from the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:54.659252Z",
     "start_time": "2021-10-03T15:24:54.640699Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python', 2: 'Java', 3: 'C++', 4: 'PHP'}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "\n",
    "print(str(dict))\n",
    "dict.clear()\n",
    "print(str(dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`copy()`** - The method `copy()` returns a shallow copy of the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:55.398522Z",
     "start_time": "2021-10-03T15:24:55.378016Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python', 2: 'Java', 3: 'C++', 4: 'PHP'}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict1 = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "dict2=dict1.copy()\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`itmes()`** - The method `items()` returns a list of dict's (key, value) tuple pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:56.016694Z",
     "start_time": "2021-10-03T15:24:56.001074Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([(1, 'Python'), (2, 'Java'), (3, 'C++'), (4, 'PHP')])\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict1 = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "print(dict1.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`keys()`** - The method `keys()` returns a list of all the available keys in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:56.801865Z",
     "start_time": "2021-10-03T15:24:56.792102Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys([1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict1 = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "all_keys=dict1.keys()\n",
    "print(all_keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`fromkeys()`** - The method `fromkeys()` creates a new dictionary with keys from seq and values set to value.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python \n",
    "dict.fromkeys(seq[, value])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:57.402460Z",
     "start_time": "2021-10-03T15:24:57.384888Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New Dictionary : {'java': None, 'python': None, 'c++': None}\n",
      "New Dictionary : {'java': 50, 'python': 50, 'c++': 50}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "seq = ('java', 'python', 'c++')\n",
    "dict = dict.fromkeys(seq)\n",
    "\n",
    "print (\"New Dictionary : %s\" % str(dict))\n",
    "dict = dict.fromkeys(seq, 50)\n",
    "print (\"New Dictionary : %s\" % str(dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`setdefault()`** - The method `setdefault()` is similar to `get` but will set `dict[key] = default` if key is not already in dict.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "dict.setdefault(key, default = None)\n",
    "```\n",
    "\n",
    "* key −> This is the key to be searched. \n",
    "* default −> This is the Value to be returned in case key is not found. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:58.004034Z",
     "start_time": "2021-10-03T15:24:57.984506Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milan\n",
      "JLUFE\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict={'emp_name':'Milan','age':32,'emp_id':101}\n",
    "dict.setdefault('company','JLUFE')\n",
    "print(dict['emp_name'])\n",
    "print(dict['company'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`update()`** - The method `update()` adds dictionary dict2's key-values pairs in to dict. This function does not return anything.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "dict.update(dict2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:58.542619Z",
     "start_time": "2021-10-03T15:24:58.535783Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Python3', 2: 'Java', 3: 'C++', 4: 'PHP', 5: 'C'}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict1 = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "dict2= {1: 'Python3',5:'C'} #update Python to Python3\n",
    "dict1.update(dict2)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`value()`** - The method `values()` returns a list of all the values available in a given dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:59.022118Z",
     "start_time": "2021-10-03T15:24:59.010400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['Python', 'Java', 'C++', 'PHP'])\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "dict1 = {1:'Python',2:'Java',3:'C++',4 : 'PHP'}\n",
    "values= dict1.values()\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a complete list of all the **[built-in methods to work with Dictionary in Python](https://github.com/milaan9/02_Python_Datatypes/tree/main/005_Python_Dictionary_Methods)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Dictionary Comprehension\n",
    "\n",
    "Dictionary comprehension is an elegant and concise way to create a new dictionary from an iterable in Python.\n",
    "\n",
    "Dictionary comprehension consists of an expression pair **`(key: value)`** followed by a **`for`** statement inside curly braces **`{}`**.\n",
    "\n",
    "Here is an example to make a dictionary with each item being a pair of a number and its square."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:24:59.697909Z",
     "start_time": "2021-10-03T15:24:59.680335Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n"
     ]
    }
   ],
   "source": [
    "# Example: Dictionary Comprehension\n",
    "\n",
    "squares = {x: x*x for x in range(6)}\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:25:00.281910Z",
     "start_time": "2021-10-03T15:25:00.272143Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "squares = {}\n",
    "for x in range(6):\n",
    "    squares[x] = x*x\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary comprehension can optionally contain more **[for](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)** or **[if](https://github.com/milaan9/03_Python_Flow_Control/blob/main/001_Python_if_statement.ipynb)** statements.\n",
    "\n",
    "An optional **`if`** statement can filter out items to form the new dictionary.\n",
    "\n",
    "Here are some examples to make a dictionary with only odd items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:25:00.836601Z",
     "start_time": "2021-10-03T15:25:00.823910Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}\n"
     ]
    }
   ],
   "source": [
    "# Example: Dictionary Comprehension with if conditional\n",
    "\n",
    "odd_squares = {x: x*x for x in range(11) if x % 2 == 1}\n",
    "print(odd_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn more dictionary comprehensions, visit **[Python Dictionary Comprehension](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary_Methods/Python_Dictionary_Comprehension.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Dictionary Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Dictionary Membership Test\n",
    "\n",
    "We can test if a **`key`** is in a dictionary or not using the keyword **`in`**. Notice that the membership test is only for the **`keys`** and not for the **`values`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:25:02.965546Z",
     "start_time": "2021-10-03T15:25:02.944061Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Example: Membership Test for Dictionary Keys\n",
    "\n",
    "squares = {1: 1, 3: 9, 5: 25, 7: 99, 9: 61}\n",
    "\n",
    "print(1 in squares)      # Output: True\n",
    "\n",
    "print(2 not in squares)  # Output: True\n",
    "\n",
    "# membership tests for key only not value\n",
    "print(99 in squares)     # Output: False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Iterating Through a Dictionary\n",
    "\n",
    "We can iterate through each key in a dictionary using a **`for`** loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T15:25:04.387444Z",
     "start_time": "2021-10-03T15:25:04.376702Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "9\n",
      "25\n",
      "49\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "# Example: Iterating through a Dictionary\n",
    "\n",
    "squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}\n",
    "for i in squares:\n",
    "    print(squares[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Dictionary</span>\n",
    "\n",
    "1. Create an empty dictionary called **`bird`**\n",
    "2. Add **`name`**, **`color`**, **`breed`**, **`legs`**, **`age`** to the **`bird`** dictionary\n",
    "3. Create a **`student`** dictionary and add **`first_name`**, **`last_name`**, **`gender`**, **`age`**, **`marital_status`**, **`skills`**, **`country`**, **`city`** and **`address`** as keys for the dictionary\n",
    "3. Get the length of the **`student`** dictionary\n",
    "4. Get the value of **`skills`** and check the data type, it should be a list\n",
    "5. Modify the **`skills`** values by adding one or two skills\n",
    "6. Get the dictionary keys as a list\n",
    "7. Get the dictionary values as a list\n",
    "8. Change the dictionary to a list of tuples using **`items()`** method\n",
    "9. Delete one of the items in the dictionary\n",
    "10. Delete one of the dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}