10 MongoDB-Todo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MongoDB\n",
    "\n",
    "Based on https://docs.mongodb.com/getting-started \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MongoDB is a **NoSQL** open-source **document database**.  MongoDB provides horizontal scaling by replicating and partitioning the data over multiple nodes. This can improve the reliability and scalability of the system.\n",
    "\n",
    "A record in MongoDB is a **document**, which is a data structure composed of field and value pairs. MongoDB documents are similar to JSON objects or Python dictionaries. The values of fields may include other documents, arrays, and arrays of documents.\n",
    "\n",
    "This is an example of a document:\n",
    "```JSON\n",
    "{\n",
    "   \"_id\" : ObjectId(\"54c955492b7c8eb21818bd09\"),\n",
    "   \"address\" : {\n",
    "      \"street\" : \"2 Avenue\",\n",
    "      \"zipcode\" : \"10075\",\n",
    "      \"building\" : \"1480\",\n",
    "      \"coord\" : [ -73.9557413, 40.7720266 ]\n",
    "   },\n",
    "   \"borough\" : \"Manhattan\",\n",
    "   \"cuisine\" : \"Italian\",\n",
    "   \"grades\" : [\n",
    "      {\n",
    "         \"date\" : ISODate(\"2014-10-01T00:00:00Z\"),\n",
    "         \"grade\" : \"A\",\n",
    "         \"score\" : 11\n",
    "      },\n",
    "      {\n",
    "         \"date\" : ISODate(\"2014-01-16T00:00:00Z\"),\n",
    "         \"grade\" : \"B\",\n",
    "         \"score\" : 17\n",
    "      }\n",
    "   ],\n",
    "   \"name\" : \"Vella\",\n",
    "   \"restaurant_id\" : \"41704620\"\n",
    "}\n",
    "```\n",
    "In MongoDB, documents have a unique **_id** field that acts as a primary key. MongoDB automatically adds a unique _id to each document if you are not providing it by yourself.\n",
    "\n",
    "MongoDB stores documents in **collections**. Collections are analogous to tables in relational databases. Unlike a table, however, a collection does not require its documents to have the same schema.\n",
    "\n",
    "You can start a Docker image with MongoDB like this:\n",
    "```bash\n",
    "docker run -p 27017:27017 -d mongo\n",
    "```\n",
    "\n",
    "In production you really (!) would need to enable authentication with username and password, but for development purposes this is fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Install the pymongo Python Package \n",
    "# !pip3 install pymongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from pymongo import MongoClient\n",
    "from pprint import pprint\n",
    "import requests "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use MongoClient to create a connection. If you do not specify any arguments to MongoClient, then MongoClient defaults to the MongoDB instance that runs on the localhost interface on port 27017. You can also specify a complete MongoDB URI to define the connection, including explicitly specifying the host and port number. For example, the following creates a connection to a MongoDB instance that runs on mongodb0.example.net and the port of 27017: client = MongoClient(\"mongodb://mongodb0.example.net:27017\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Client connects to \"localhost\" by default \n",
    "client = MongoClient()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first fundamental class of objects you will interact with using pymongo is Database which represents the database construct in MongoDB. Databases hold groups of logically related collections. MongoDB creates new databases implicitly upon their first use. Connect (create) with a database of your name, e.g. \n",
    "\n",
    "```python\n",
    "db = client[\"rolandmueller\"]\n",
    "``` \n",
    "or \n",
    "\n",
    "```python\n",
    "db = client.rolandmueller\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create local \"bipm\" database on the fly \n",
    "db = client['bipm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# When we rerun the whole notebook, we start from scratch \n",
    "# by dropping the colection \"courses\"\n",
    "db.courses.drop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a Python Dictonary\n",
    "courses = [\n",
    "    {'title': 'Data Science',\n",
    "     'lecturer': {\n",
    "         'name': 'Markus Löcher',\n",
    "         'department': 'Math',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 1},\n",
    "    {'title': 'Data Warehousing',\n",
    "     'lecturer': {\n",
    "         'name': 'Roland M. Mueller',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 1},\n",
    "    {'title': 'Business Process Management',\n",
    "     'lecturer': {\n",
    "         'name': 'Frank Habermann',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 1},\n",
    "    {'title': 'Stratigic Issues of IT',\n",
    "     'lecturer': {\n",
    "         'name': 'Sven Pohland',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 1},\n",
    "    {'title': 'Text, Web and Social Media Analytics Lab',\n",
    "     'lecturer': {\n",
    "         'name': 'Markus Löcher',\n",
    "         'department': 'Math',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 2},\n",
    "    {'title': 'Enterprise Architectures for Big Data',\n",
    "     'lecturer': {\n",
    "         'name': 'Roland M. Mueller',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 2},\n",
    "    {'title': 'Business Process Integration Lab',\n",
    "     'lecturer': {\n",
    "         'name': 'Frank Habermann',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 2},\n",
    "    {'title': 'IT-Security and Privacy',\n",
    "     'lecturer': {\n",
    "         'name': 'Dennis Uckel',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'External'\n",
    "     },\n",
    "     'semester': 2},\n",
    "    {'title': 'Research Methods',\n",
    "     'lecturer': {\n",
    "         'name': 'Marcus Birkenkrahe',\n",
    "         'department': 'Information Systems',\n",
    "         'status': 'Professor'\n",
    "     },\n",
    "     'semester': 2},\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'lecturer': {'department': 'Math',\n",
      "               'name': 'Markus Löcher',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 1,\n",
      "  'title': 'Data Science'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Roland M. Mueller',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 1,\n",
      "  'title': 'Data Warehousing'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Frank Habermann',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 1,\n",
      "  'title': 'Business Process Management'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Sven Pohland',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 1,\n",
      "  'title': 'Stratigic Issues of IT'},\n",
      " {'lecturer': {'department': 'Math',\n",
      "               'name': 'Markus Löcher',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 2,\n",
      "  'title': 'Text, Web and Social Media Analytics Lab'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Roland M. Mueller',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 2,\n",
      "  'title': 'Enterprise Architectures for Big Data'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Frank Habermann',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 2,\n",
      "  'title': 'Business Process Integration Lab'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Dennis Uckel',\n",
      "               'status': 'External'},\n",
      "  'semester': 2,\n",
      "  'title': 'IT-Security and Privacy'},\n",
      " {'lecturer': {'department': 'Information Systems',\n",
      "               'name': 'Marcus Birkenkrahe',\n",
      "               'status': 'Professor'},\n",
      "  'semester': 2,\n",
      "  'title': 'Research Methods'}]\n"
     ]
    }
   ],
   "source": [
    "pprint(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## insert_many()\n",
    "\n",
    "You can use the `insert_one()` method and the `insert_many()` method to add documents to a collection in MongoDB. If you attempt to add documents to a collection that does not exist, MongoDB will create the collection for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pymongo.results.InsertManyResult at 0x10ef67ac8>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.courses.insert_many(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## find()\n",
    "\n",
    "You can use the find() method to issue a query to retrieve data from a collection in MongoDB. All queries in MongoDB have the scope of a single collection.\n",
    "Queries can return all documents in a collection or only the documents that match a specified filter or criteria. You can specify the filter or criteria in a document and pass as a parameter to the find() method. With no parameter, find() returns all documents in the collection.\n",
    "\n",
    "The find() method returns query results in a cursor, which is an iterable object that yields documents. Then you can print all documents.\n",
    "\n",
    "```python\n",
    "cursor = db.my_collection.find()\n",
    "\n",
    "for document in cursor:\n",
    "    pprint(document)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Print all courses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON\n",
    "\n",
    "You can store a JSON document if you convert it before to a Python dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'semester': 3, 'title': 'Master Thesis'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_json = '{\"title\": \"Master Thesis\", \"semester\": 3}'\n",
    "another_course = json.loads(my_json)\n",
    "another_course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## insert_one()\n",
    "\n",
    "The `insert_one()` method adds the document into the collection.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Store `another_course` as another course:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Print all courses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## find_one() and find()\n",
    "\n",
    "`find_one()` returns the first match. ```find()```returns all matches.\n",
    "\n",
    "The query condition for `find_one()` and `find()` for an equality match on fields has the following form:\n",
    "```python\n",
    "{ <field1>: <value1>, <field2>: <value2>, ... } \n",
    "```\n",
    "\n",
    "The following operation finds the first documents whose name field equals \"Manhattan\".\n",
    "\n",
    "```python\n",
    "cursor = db.restaurants.find_one({\"name\": \"Manhattan\"})\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find the course with the title \"Data Science\" \n",
    "# save the result in a varibale result\n",
    "# and pprint the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5cc57fee6879c205b3f26031\n",
      "Markus Löcher\n"
     ]
    }
   ],
   "source": [
    "print(result[\"_id\"])\n",
    "print(result[\"lecturer\"][\"name\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find the first course (one course) in the second semester\n",
    "# and print it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find all courses in the second semester\n",
    "# and print the course titles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find all courses in the second semester\n",
    "# and print the lecturers names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subelements\n",
    "\n",
    "Sometimes documents contains embedded documents as its elements. To specify a condition on a field in these documents, use the dot notation. Dot notation requires quotes around the whole dotted field name. The following queries for documents whose grades array contains an embedded document with a field grade equal to \"B\".\n",
    "\n",
    "```python\n",
    "cursor = db.restaurants.find({\"grades.grade\": \"B\"})\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find all courses of Frank Habermann\n",
    "# and print the title and the semester"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical AND\n",
    "\n",
    "You can specify a logical conjunction (AND) for a list of query conditions by separating the conditions with a comma in the conditions document.\n",
    "\n",
    "```python\n",
    "cursor = db.restaurants.find({\"cuisine\": \"Italian\", \"address.zipcode\": \"10075\"})\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find all courses from Frank Habermann in the second semester\n",
    "# and print the title and the semester"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical OR\n",
    "\n",
    "You can specify a logical disjunction (OR) for a list of query conditions by using the $or query operator.\n",
    "\n",
    "```python\n",
    "cursor = db.restaurants.find({\"$or\": [{\"cuisine\": \"Italian\"}, {\"address.zipcode\": \"10075\"}]})\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TODO: Find all courses from Frank Habermann or Markus Löcher\n",
    "# and print the title and the semester"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Greater than, Less than\n",
    "\n",
    "MongoDB provides operators to specify query conditions, such as comparison operators. Query conditions using operators generally have the following form:\n",
    "```python\n",
    "{ <field1>: { <operator1>: <value1> } }\n",
    "```\n",
    "\n",
    "Greater Than Operator (`$gt`). Query for documents whose grades array contains an embedded document with a field score greater than 30.\n",
    "\n",
    "```python\n",
    "cursor = db.restaurants.find({\"grades.score\": {\"$gt\": 30}})\n",
    "```\n",
    "\n",
    "Less Than Operator (`$lt`). Query for documents whose grades array contains an embedded document with a field score less than 10.\n",
    "\n",
    "```python\n",
    "cursor = db.restaurants.find({\"grades.score\": {\"$lt\": 10}})\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TODO: Find all courses in semester greater than 1\n",
    "# and print the title and the semester"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counting\n",
    "\n",
    "`count_documents()` works like `find()` but returns the number of matched documents-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: How many courses are in the second semester?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Downloading Nobel Prize Winners with an API and storing them in MongoDB\n",
    "\n",
    "![](https://upload.wikimedia.org/wikipedia/en/e/ed/Nobel_Prize.png)\n",
    "The Nobel Prize offers a Web API https://nobelprize.readme.io/docs/prize\n",
    "\n",
    "Because the API is giving us JSON and MongoDB is able to store documents in a JSON-like format, using a document database like MongoDB seems like a good fit to store the results of the API.  You can get all laureates at http://api.nobelprize.org/v1/laureate.json and all prizes at http://api.nobelprize.org/v1/prize.json\n",
    "\n",
    "We will just download all laureates and prizes and store them in MongoDB!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create local \"nobel\" database on the fly \n",
    "db = client[\"nobel\"]\n",
    "db.prizes.drop()\n",
    "db.laureates.drop()\n",
    "# API documented at https://nobelprize.readme.io/docs/prize \n",
    "for collection_name in [\"prizes\", \"laureates\"]:\n",
    "    singular = collection_name[:-1] # the API uses singular\n",
    "    response = requests.get( \"http://api.nobelprize.org/v1/{}.json\".format(singular)) \n",
    "    documents = response.json()[collection_name] \n",
    "    # Create collections on the fly \n",
    "    db[collection_name].insert_many(documents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_id': ObjectId('5cc5806d6879c205b3f2687d'),\n",
      " 'born': '1845-03-27',\n",
      " 'bornCity': 'Lennep (now Remscheid)',\n",
      " 'bornCountry': 'Prussia (now Germany)',\n",
      " 'bornCountryCode': 'DE',\n",
      " 'died': '1923-02-10',\n",
      " 'diedCity': 'Munich',\n",
      " 'diedCountry': 'Germany',\n",
      " 'diedCountryCode': 'DE',\n",
      " 'firstname': 'Wilhelm Conrad',\n",
      " 'gender': 'male',\n",
      " 'id': '1',\n",
      " 'prizes': [{'affiliations': [{'city': 'Munich',\n",
      "                               'country': 'Germany',\n",
      "                               'name': 'Munich University'}],\n",
      "             'category': 'physics',\n",
      "             'motivation': '\"in recognition of the extraordinary services he '\n",
      "                           'has rendered by the discovery of the remarkable '\n",
      "                           'rays subsequently named after him\"',\n",
      "             'share': '1',\n",
      "             'year': '1901'}],\n",
      " 'surname': 'Röntgen'}\n"
     ]
    }
   ],
   "source": [
    "pprint(db.laureates.find_one())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Print the first name of the first document"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `count_documents` you can count the number of matching documents. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many female laureates exists? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the `$regex` function you can use a regular expression. `distinct` list only all distinct entries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Prussia (now Germany)',\n",
       " 'Hesse-Kassel (now Germany)',\n",
       " 'Germany',\n",
       " 'Schleswig (now Germany)',\n",
       " 'Germany (now Poland)',\n",
       " 'Germany (now France)',\n",
       " 'West Germany (now Germany)',\n",
       " 'Bavaria (now Germany)',\n",
       " 'Germany (now Russia)',\n",
       " 'Mecklenburg (now Germany)',\n",
       " 'W&uuml;rttemberg (now Germany)',\n",
       " 'East Friesland (now Germany)']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.laureates.distinct(\"bornCountry\", {\"bornCountry\": {\"$regex\": \"Germany\"}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: How many laureates are from Germany?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find all physics nobel laureates that are from Germany\n",
    "# print the year of the first prize, the first name, and surename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TODO: find and print the document for \"Malala\" (firstname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sort()\n",
    "\n",
    "With `sort()` you can sort the list of documents. The parameter of sort is a list of sorting tuples. Each tuple is a value and an integer value 1 or -1 which states whether the collection to be sorted in ascending (1) or descending (-1) order.\n",
    "\n",
    "Sort all restaurants according to the grade in ascending order.\n",
    "```python\n",
    "cursor = db.restaurants.find().sort([(\"grades.grade\", 1)])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Find only female nobel laureates \n",
    "# and sort them according the the prize year in ascending order\n",
    "# print year of the first prize, firstname, and surename"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.6.1"
  },
  "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
}