01.04 Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": true,
    "toc": true
   },
   "source": [
    "<h1>Variables<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Defining-basic-variables\" data-toc-modified-id=\"Defining-basic-variables-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Defining basic variables</a></span><ul class=\"toc-item\"><li><span><a href=\"#Variable--and-filenames\" data-toc-modified-id=\"Variable--and-filenames-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Variable- and filenames</a></span></li><li><span><a href=\"#The-type-command\" data-toc-modified-id=\"The-type-command-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>The <code>type</code> command</a></span></li></ul></li><li><span><a href=\"#Lists\" data-toc-modified-id=\"Lists-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Lists</a></span></li><li><span><a href=\"#Indexing-and-slicing\" data-toc-modified-id=\"Indexing-and-slicing-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Indexing and slicing</a></span><ul class=\"toc-item\"><li><span><a href=\"#The-len-command\" data-toc-modified-id=\"The-len-command-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>The <code>len</code> command</a></span></li><li><span><a href=\"#Exercise-1\" data-toc-modified-id=\"Exercise-1-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Exercise 1</a></span></li></ul></li><li><span><a href=\"#Tuples\" data-toc-modified-id=\"Tuples-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Tuples</a></span></li><li><span><a href=\"#Dictionaries\" data-toc-modified-id=\"Dictionaries-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Dictionaries</a></span><ul class=\"toc-item\"><li><span><a href=\"#The-pprint-command\" data-toc-modified-id=\"The-pprint-command-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>The pprint-command</a></span></li><li><span><a href=\"#Changing-dictionary-entries\" data-toc-modified-id=\"Changing-dictionary-entries-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Changing dictionary entries</a></span></li></ul></li><li><span><a href=\"#Summary:-Fundamental-data-types-and-structures\" data-toc-modified-id=\"Summary:-Fundamental-data-types-and-structures-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Summary: Fundamental data types and structures</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Defining basic variables\n",
    "In the previous chapters, you've already learned how to define your first variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Defining \"number\" variables:\n",
    "a = 5\n",
    "b = 20\n",
    "c = b/a\n",
    "print(\" \")\n",
    "print(c) # this is my comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Defining \"text\" (string) variables:\n",
    "text_A = \"Hello, my name is\"\n",
    "text_B = \"Gandalf\"\n",
    "\n",
    "print(text_A, text_B)\n",
    "print(text_A + \" \" + text_B) # Alternative expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following data types are the most common ones in many (scientific) programming languages:\n",
    "\n",
    "- integer\n",
    "- float\n",
    "- complex\n",
    "- strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# most common scientific data types:\n",
    "integer_number   = 1                # integer numbers\n",
    "float_number     = 1.0              # floating point numbers\n",
    "complex_number   = 1 + 2j           # complex numbers\n",
    "string_1         = \"a string\"       # strings, defined via '\n",
    "string_2         = 'also a string'  # strings, defined via \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, that you can define strings via ' or \". \n",
    "\n",
    "### Variable- and filenames\n",
    "In _Python_, the following signs are allowed in variable names:\n",
    "\n",
    "- capital letters A to Z\n",
    "- lowercase letters a to z\n",
    "- underscore _\n",
    "- numbers 0 to 9 (not in the first place!)\n",
    "\n",
    "Hence, don't start a variable name with a number and don't use special characters. Also, don't use built-in function names or variables as a variable name (e.g., don't use `print = 7`, `list = 9`, and so forth)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `type` command\n",
    "You can check the data type of any variable by the `type(variable)` command, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(type(integer_number))\n",
    "print(type(float_number))\n",
    "print(type(complex_number))\n",
    "print(type(string_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Lists are\n",
    "\n",
    "- one-dimensional \"_arrays_\" of numbers or strings\n",
    "- created with `[ … , … , … ]`\n",
    "- indexing, slicing, adding, replacing and dropping allowed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number list:\n",
    "number_list = [33, 37, 38, 39]\n",
    "print(\"number list:\", number_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# string list:\n",
    "#pos./index: 1/0     2/1    3/2    4/3  \n",
    "word_list = [\"my\", \"name\", \"is\", \"Gandalf\"]\n",
    "print(\"word list:\", word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build a list from other pre-defined variables:\n",
    "a = 7\n",
    "b = 99\n",
    "c = a+b\n",
    "variable_list = [a, b, c, 67]\n",
    "print(\"variable list:\", variable_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One often very useful built-in list command is `list_variable.append(new entry)`, which appends new list entries to a pre-defined list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "word_list.append(\" and yours?\")\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_list.append(77)\n",
    "print(number_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# open the help for lists:\n",
    "help(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "number_list.insert(1,99999)\n",
    "print(number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use individual list entries and plug them into another variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = word_list[2]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing and slicing\n",
    "Speicific elements of any indexable and sliceable variable can be accessed in the following ways:\n",
    "\n",
    "- **index** an element with `[]`, i.e., `your_list[index]`, e.g.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(word_list[0])\n",
    "print(word_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **slice** a subset of the list with `[start:stop]`, i.e., `your_list[start:stop]`\n",
    " - leaving `start` or `stop` empty (`[:stop]` or `[start:]`) slices from the first or to the last element, respectively.\n",
    " - slicing to -1, -2, -3 ... means slicing until the penultimate, second to last, third to last .. element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(word_list[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list[:]) # similar to print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(word_list[0:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list[-3:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list[-2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also slice and index by using variables as placeholder, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "j = 4\n",
    "\n",
    "print(word_list[i])\n",
    "print(word_list[i:j])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Zero-based indexing:</b> Python uses an index starting at zero and defines intervals as closed on the left and open on the right (i.e., the lower bound is included, but the upper bound is not).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also modify/\"overwrite\" specific list entries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "word_list[3] = \"Pluto\"\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "word_list[2] = 3 * 7\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(word_list[0:1])\n",
    "print(word_list[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tester_a = word_list[0:1]\n",
    "tester_b = word_list[0]\n",
    "print(type(tester_a))\n",
    "print(type(tester_b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_array = [0, 1, 2, 3, 5, 6, 7, 8, 9, 10]\n",
    "marker = 8\n",
    "n=2\n",
    "# task: find the n-th value before marker (6)\n",
    "print(long_array[2:marker-n])\n",
    "#print(long_array[2:-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `len` command\n",
    "With the `len(variable)` command you can check the length of any Python array-like variable, e..g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(word_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(len(word_list))\n",
    "N = len(word_list)\n",
    "print(\"N:\", N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with any result, you can plug the output expression into a new variable and re-use it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "N = len(word_list)\n",
    "print(N)\n",
    "print(N + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Please repeat the indexing and slicing commands for `number_list = [33, 37, 38, 39]`:\n",
    "\n",
    "1. Print the first and second list element.\n",
    "2. Slice from the first to the second (including) element.\n",
    "3. Slice from the second to the last (including) element.\n",
    "4. Slice from the first to the last (including) element.\n",
    "5. Replace the third element by the number 87.    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1.1 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.1:\n",
    "number_list = [33, 37, 38, 39]\n",
    "\n",
    "# Print the first and second list element:\n",
    "print(\">>>\")\n",
    "print(number_list[0])\n",
    "print(number_list[1])\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1.2:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.2:\n",
    "# Slice from the first to the second (including) element:\n",
    "print(\">>>\")\n",
    "print(number_list[0:2])\n",
    "print(number_list[:2])\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1.3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.3:\n",
    "# Slice from the second to the last (including) element:\n",
    "print(\">>>\")\n",
    "print(number_list[1:])\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1.4 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.4:\n",
    "# Slice from the first to the last (including) element:\n",
    "print(\">>>\")\n",
    "print(number_list[:])\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1.5 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 1.5:\n",
    "# Replace the third element by the number 87:\n",
    "number_list[2] = 87\n",
    "print(\">>>\")\n",
    "print(number_list)\n",
    "``` \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "Tuples are very similar to lists, with the following differences:\n",
    "\n",
    "- tuples are created via `(..., ..., ...,)`\n",
    "- tuples are like lists, but not mutable (no adding/appending, replacing and dropping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_example = (1, 11, 999)\n",
    "print(tuple_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(tuple_example[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tuple_example[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"_... but **not mutable**_\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_example[1] = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "Dictionaries are a bit more structured array-like variables, where the individual indices are assigne to a specific `key`:\n",
    "\n",
    "- dictionaries are created via `{‘key1’: values1, ‘key2’: values2, …}`\n",
    "- `value` can be any object\n",
    "- entries can be indexed via their `key`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "mouse = {'ID': 45768,\n",
    "         'age': 42,\n",
    "         'sex': \"male\",\n",
    "         'weight': 36,\n",
    "         'MWM_scores': [59, 50, 40, 27, 14, 11]}\n",
    "print(mouse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"mouse's ID:\", mouse[\"ID\"])\n",
    "print(\"mouse's Age:\", mouse[\"age\"])\n",
    "print(\"mouse's Morris Water Maze scores:\", \n",
    "      mouse[\"MWM_scores\"])\n",
    "print(\"Male or Female?:\", mouse[\"sex\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The pprint-command\n",
    "To print out array-like variables in a more readable, row-like format, you can use the pprint command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from pprint import pprint as pprint\n",
    "pprint(mouse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing dictionary entries\n",
    "Of course you can also add and update dictionary entries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Updating/overwriting and existing entry:\n",
    "mouse[\"age\"] = 99\n",
    "pprint(mouse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Adding a new key + entry/value:\n",
    "mouse[\"Group\"] = \"Group A\"\n",
    "pprint(mouse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mouse[\"MWM_scores\"])\n",
    "print(mouse[\"MWM_scores\"][3])\n",
    "mouse[\"MWM_scores\"][3] = 999\n",
    "print(mouse[\"MWM_scores\"][3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary: Fundamental data types and structures\n",
    "- **Lists**\n",
    "    - one-dimensional \"_arrays_\" of numbers or strings\n",
    "    - created with `[ ... , ... , ...]`\n",
    "    - indexing, slicing, adding, replacing and dropping allowed\n",
    "- **Tuples**\n",
    "    - one-dimensional \"_arrays_\" of numbers or strings\n",
    "    - created with `( ... , ... , ...)`\n",
    "    - indexing and slicing possible\n",
    "    - adding, replacing and dropping not possible\n",
    "- **Dictionaries**\n",
    "    - dictionaries are created via `{‘key1’: values1, ‘key2’: values2, …}`\n",
    "    - `value` can be any object\n",
    "    - entries can be indexed via their `key`\n",
    "- **NumPy arrays**\n",
    "    - this we will learn later\n",
    "- **Pandas DataFrames**\n",
    "    - this we will learn later\n",
    "\n",
    "Allowed signs in variable names:\n",
    "- capital letters A to Z\n",
    "- lowercase letters a to z\n",
    "- underscore _\n",
    "- numbers 0 to 9 (not in the first place!)"
   ]
  }
 ],
 "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.16 | packaged by conda-forge | (default, Feb  1 2023, 16:05:36) \n[Clang 14.0.6 ]"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Variables",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "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
  },
  "vscode": {
   "interpreter": {
    "hash": "4dbe93ddc4bed5499d29720f38f7446a34b15f2f3201b881b9bf1c1a4baa393f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}