Part.1.E.4.functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数，实际上是可被调用的完整的程序。它具备输入、处理、输出的功能。又因为它经常在主程序里被调用，所以它总是更像是个子程序。\n",
    "\n",
    "了解一个函数，无非是要了解它的两个方面：\n",
    "\n",
    "> * 它的**输入**是怎么构成的（都有哪些参数？如何指定？）；\n",
    "> * 以及它的**输出**是什么（返回值究竟是什么？）……\n",
    "\n",
    "从这个角度看，牛，对人类来说就是个函数，它吃的是_草_，挤出来的是*奶*…… 开玩笑了。\n",
    "\n",
    "在我们使用函数的过程中，我们常常_有意忽略_它的内部如何完成从输出到输出之间的_处理过程_ —— 这就好像我们平日里用灯泡一样，大多数情况下，我们只要知道开关的使用方法就够了 —— 至于为什么按到这个方向上灯会亮，为什么按到另外一个方向上灯会灭，并不是我们作为用户必须关心的事情…… \n",
    "\n",
    "当然，如果你是设计开关的人就不一样了，你必须知道其中的运作原理；但是，最终，你还是希望你的用户用最简单方便的操作界面，而不是必须搞懂所有原理才能够使用你所设计的产品……\n",
    "\n",
    "当我们用 Python 编程的时候，更多的情况下，我们只不过是在使用别人已经写好的函数，或者用更专业一点的词藻，叫做“已完好封装的函数”。而我们所需要做的事情（所谓的“学习使用函数”），其实只不过是“通过阅读产品说明书了解如何使用产品”而已，真的没多神秘……\n",
    "\n",
    "**注意**\n",
    "\n",
    "> 这一章的核心目的，不是让你学会如何写函数；而是通过一些例子，让你大抵上学会“_如何阅读官方文档中关于函数的使用说明_”。也请注意之前的那个词：“_大抵上_”，所以**千万别怕自己最初的时候理解不全面**。\n",
    "\n",
    "另外，这一章中用来举例的函数，全部来自于同一个官方文档页面，[Built-in Functions](https://docs.python.org/3/library/functions.html)：\n",
    "\n",
    "> https://docs.python.org/3/library/functions.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 示例 print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基本的使用方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print()` 是初学者最常遇到的函数 —— 姑且不说是不是最常用到的。\n",
    "\n",
    "它最基本的作用就是把传递给它的值输出到屏幕上，如果不给它任何参数，那么它就输出一个空行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line 1st\n",
      "line 2nd\n",
      "\n",
      "line 4th\n"
     ]
    }
   ],
   "source": [
    "print('line 1st')\n",
    "print('line 2nd')\n",
    "print()\n",
    "print('line 4th')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你也可以向它传递多个参数，它就会把那些值逐个输出到屏幕，每个值之间用空格分开。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, jack mike ... and all you guys!\n"
     ]
    }
   ],
   "source": [
    "print('Hello,', 'jack', 'mike', '...', 'and all you guys!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们想把变量或者表达式的值插入字符串中的时候，可以用 f-string："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ann is 22 years old.\n"
     ]
    }
   ],
   "source": [
    "name = 'Ann'\n",
    "age = '22'\n",
    "print(f'{name} is {age} years old.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但，这并不是 `print()` 这个函数的功能，这实际上是 [`f-string`](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting) 的功能，`f-string` 中用花括号 `{}` 扩起来的部分是表达式，最终转换成字符串的时候，那些表达式的值（而不是变量或者表达式本身）会被插入相应的位置……"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ann is 22 years old.'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Ann'\n",
    "age = '22'\n",
    "f'{name} is {age} years old.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所以，`print(f'{name} is {age} years old.')` 这一句中，函数 `print()` 完成的还是它最基本的功能：给它什么，它就把什么输出到屏幕上。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### print() 的官方文档说明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下，是 print() 这个函数的[官方文档](https://docs.python.org/3/library/functions.html#print)：\n",
    "\n",
    "![](images/doc-print.png)\n",
    "\n",
    "最必须读懂的部分，就是这一行：\n",
    "\n",
    "> `print(*object, sep=' ', end='\\n', file=sys.stdout, flush=False)` <a href='#fn1' name='fn1b'><sup>[1]</sup></a>\n",
    "\n",
    "先只注意那些有着 `=` 的参数，`sep=' '`、`end='\\n'`、`file=sys.stdout`，和 `flush=False`。\n",
    "\n",
    "这其中，先关注这三个 `sep=' '`、`end='\\n'`、`file=sys.stdout`：\n",
    "\n",
    "> * `sep=' '`：接收多个参数之后，输出时，分隔符号默认为空格，`' '`；\n",
    "> * `end='\\n'`：输出行的末尾默认是换行符号 `'\\n'`；\n",
    "> * `file=sys.stdout`：默认的输出对象是 `sys.stout`（即，用户正在使用的屏幕）……\n",
    "\n",
    "也就是说，这个函数中有若干个具有默认值的参数，即便我们在调用这个函数的时候，就算没有指定它们，它们也存在于此。\n",
    "\n",
    "即，当我们调用 `print('Hello', 'world!')` 的时候，相当于我们调用的是 `print('Hello', 'world!', sep=' ', end='\\n', file=sys.stdout, flush=False)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "Hello world!\n",
      "Hello-world!\tHello~world!\n",
      "Hello\n",
      "world!\n"
     ]
    }
   ],
   "source": [
    "import sys                                  # 如果没有这一行，代码会报错\n",
    "\n",
    "print('Hello', 'world!')                    # 下一行的输出和这一行相同\n",
    "print('Hello', 'world!', sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
    "print('Hello', 'world!', sep='-', end='\\t')\n",
    "print('Hello', 'world!', sep='~')           # 上一行的末尾是 \\t，所以，这一行并没有换行显示\n",
    "print('Hello', 'world!', sep='\\n')          # 参数之间用换行 \\n 分隔 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+2=3\n",
      "1+2=3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(1,2,sep =\"+\",end=\"\")\n",
    "print(\"=3\")\n",
    "#或者下面一种\n",
    "print(1,2,sep =\"+\",end=\"=3\")\n",
    "type(print())   # none type 是个什么鬼了 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#这个官方文档有一点不好的，就是直接看不出来return值是什么的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很多人只看各种教材、教程，却从来不去翻阅官方文档 —— 到最后非常吃亏。只不过是多花一点点的功夫而已，看过之后，就会知道：原来 `print()` 这个函数是可以往文件里写数据的，只要指定 `file` 这个参数为一个已经打开的文件对象就可以了（真的有很多人完全不知道）……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，现在可以说清楚了：\n",
    "\n",
    "> `print()` 这个函数的返回值是 `None` —— 注意，它向屏幕输出的内容，与 `print()` 这个函数的返回值不是一回事儿。\n",
    "\n",
    "做为例子，看看 `print(print(1))` 这个语句 —— `print()` 这个函数被调用了两次，第一次是 `print(1)`，它向屏幕输出了一次，完整的输出值实际上是 `str(1) + '\\n'`，而后返回一个值，`None`；而第二次调用 print()，这相当于是向屏幕输出这个 `None`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "None\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(print(1))\n",
    "type(print(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“**看说明书**”就是这样，全都看了，真不一定全部看懂，但，看总是比不看强，因为总是有能看懂的部分……\n",
    "\n",
    "\n",
    "> 在看一个例子\n",
    ">>  max(iterable, *[, key, default])  \n",
    ">> max(arg1, arg2, *args[, key])  \n",
    ">> Return the largest item in an iterable or the largest of two or more arguments.  \n",
    ">>If one positional argument is provided, it should be an iterable. The largest item in the iterable is returned. If two or more positional arguments are provided, the largest of the positional arguments is returned.  \n",
    ">>There are two optional keyword-only arguments. The key argument specifies a one-argument ordering function like that used for list.sort(). The default argument specifies an object to return if the provided iterable is empty. If the iterable is empty and default is not provided, a ValueError is raised.  \n",
    ">>If multiple items are maximal, the function returns the first one encountered. This is consistent with other sort-stability preserving tools such as sorted(iterable, key=keyfunc, reverse=True)[0] and heapq.nlargest(1, iterable, key=keyfunc).\n",
    "New in version 3.4: The default keyword-only argument.  \n",
    "\n",
    "> 这是官方对于max()函数的解释。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(2,4)\n",
    "max(2,4,5,-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关键字参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Python 中，函数的参数，有两种：\n",
    "> * **位置参数**（Positional Arguments，在官方文档里常被缩写为 *arg*）\n",
    "> * **关键字参数**（Keyward Arguments，在官方文档里常被缩写为 *karg*）\n",
    "\n",
    "在函数定义中，带有 `=` 的，即，已为其设定了默认值的参数，叫做 Keyword Arguments，其它的是 Positional Arguments。\n",
    "\n",
    "在调用有 Keyword Arguments 的函数之时，如若不提供这些参数，那么参数在执行时，启用的是它在定义的时候为那些 Keyword Arguments 所设定的默认值；如若提供了这些参数的值，那么参数在执行的时候，启用的是接收到的相应值。\n",
    "\n",
    "比如，`sorted()` 函数，它的定义如下：\n",
    "\n",
    "> `sorted(iterable, *, key=None, reverse=False)`\n",
    "\n",
    "现在先只关注它的 Keyword Arugment，`reverse`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['d', 'c', 'b', 'a']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "sorted('abdc')\n",
    "sorted('abdc', reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 位置参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "位置参数，顾名思义，是“由位置决定其值的参数”。拿 `divmod()` 为例，它的[官方文档](https://docs.python.org/3/library/functions.html#divmod)是这样写的：\n",
    "\n",
    "![](images/doc-divmod.png)\n",
    "\n",
    "它接收且必须接收两个参数。\n",
    "\n",
    "> * 当你调用这个函数的时候，括号里写的第一个参数，是被除数，第二个参数是除数 —— 此为该函数的输入；\n",
    "> * 而它的返回值，是一个元组（Tupple，至于这是什么东西，后面讲清楚），其中包括两个值，第一个是商，第二个是余 —— 此为该函数的输出。\n",
    "\n",
    "作为“这个函数的用户”，你不能（事实上也没必要）调换这两个参数的意义。因为，根据定义，被传递的值的意义就是由参数的位置决定的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(0, 3)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "divmod(11, 3)\n",
    "a, b = divmod(11, 3)\n",
    "a\n",
    "b\n",
    "\n",
    "divmod(3, 11)\n",
    "a, b = divmod(3, 11)\n",
    "a\n",
    "b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 可选位置参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有些函数，如 `pow()`，有**可选的位置参数**（Optional Positional Arguments）。\n",
    "\n",
    "![](images/doc-pow.png)\n",
    "\n",
    "于是，`pow()` 有两种用法，各有不同的结果：\n",
    "\n",
    "> * `pow(x, y)` —— 返回值是 `x ** y`\n",
    "> * `pow(x, y, z)` —— 返回值是 `x ** y % z`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "pow(2, 3)\n",
    "pow(2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意 `pow()` 函数定义部分中，圆括号内的方括号 `[, z]` —— 这是非常严谨的标注，如果没有 `z`，那么那个逗号 `,` 就是没必要的。\n",
    "\n",
    "看看 `exec()` 的官方文档（先别管这个函数干嘛用的），注意函数定义中的两个嵌套的方括号：\n",
    "\n",
    "![](images/doc-exec.png)\n",
    "\n",
    "这些方括号的意思是说：\n",
    "\n",
    "> * 没在方括号里的 `object` 是不可或缺的函数，调用时必须提供；\n",
    "> * 可以有第二个参数，第二个参数会被接收为 `globals`；\n",
    "> * 在有第二个参数的情况下，第三个参数会被接收为 `locals`；\n",
    "> * *但是，你没办法在不指定 `globals` 这个位置参数的情况下指定 `locals`……*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可接收很多值的位置参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再回头看看 `print()`，它的第一个位置参数，`object` 前面是有个星号的：`*object, ...`。\n",
    "\n",
    "对函数的用户来说，这说明，这个位置可以接收很多个参数（或者说，这个位置可以接收一个列表或者元组）。\n",
    "\n",
    "再仔细看看 `print()`，它只有一个位置参数：\n",
    "\n",
    "![](images/doc-print-def.png)\n",
    "\n",
    "因为位置决定了值的定义，一般来说，一个函数里最多只有一个这种可以接收很多值的位置参数 —— 否则如何获知谁是谁呢？\n",
    "\n",
    "如果与此同时，还有若干个位置参数，那么，*能够接收很多值的位置参数*只能放置最后，就好像 `max()` 函数那样：\n",
    "\n",
    "![](images/doc-max.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class 也是函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然你现在还不一定知道 Class 究竟是什么，但，在阅读官方文档的时候，遇到一些内建函数前面写着 Class，比如 `Class bool([x])`，千万别奇怪，因为 Class 本质上来看就是一种特殊类型的函数，也就是说，它也是函数：\n",
    "\n",
    "![](images/doc-class.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "bool()\n",
    "bool(3.1415926)\n",
    "bool(-3.1415926)\n",
    "bool(1 == 2)\n",
    "bool(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本章需要（大致）了解的重点如下，其实很简单：\n",
    "\n",
    "> * 你可以把函数当作一个产品，而你自己是这个产品的用户；\n",
    "> * 既然你是产品的用户，你要养成好习惯，一定要亲自阅读产品说明书；\n",
    "> * 调用函数的时候，注意_可选位置函数的使用方法_和_关键字函数的默认值_；\n",
    "> * 函数定义部分，注意两个符号就行了，`[]` 和 `=`；\n",
    "> * 所有的函数都有返回值，即便它内部不指定返回值，也有一个返回值：`None` ；\n",
    "> * 另外，一定要耐心阅读该函数在使用的时候需要注意什么 —— 产品说明书的主要作用就在这里……\n",
    "\n",
    "知道这些就很好了！\n",
    "\n",
    "这就好像你拿着一张地图，不可能一下子掌握其中所有的细节，但，花几分钟搞清楚“图例”（Legend）部分总是可以的，知道什么样的线标示的是公交车，什么样的线标示的是地铁，什么样的线标示的是桥梁，然后知道上北下南左西右东 —— 这之后，就可以开始慢慢研究地图了……\n",
    "\n",
    "为了学会使用 Python，你以后最常访问的页面一定是这个：\n",
    "\n",
    "> * https://docs.python.org/3/library/index.html\n",
    ">\n",
    ">   而最早反复阅读查询的页面肯定是其中的这两个：\n",
    ">   * https://docs.python.org/3/library/functions.html\n",
    ">   * https://docs.python.org/3/library/stdtypes.html\n",
    "\n",
    "对了，还有就是，在这一章之后，你已经基本上“**精通**”了 `print()` 这个函数的用法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n",
    "**脚注**\n",
    "\n",
    "</a><a name='fn1'>[1]</a>：`print()` 函数的[官方文档](https://docs.python.org/3/library/functions.html#print)里，`sep=''` 肯定是 `sep=' '` 的笔误 —— 可以用以下代码验证（2019.02.14）：\n",
    "\n",
    "```python\n",
    "print('a', 'b', sep='')\n",
    "print('a', 'b')\n",
    "```\n",
    "\n",
    "<a href='#fn1b'><small>↑Back to Content↑</small>\n"
   ]
  }
 ],
 "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.7.0"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 2
}