2_入门介绍.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 的基础介绍\n",
    "该篇通过对字符串和列表进行介绍，起到入门教程的作用(让你产生已经学完的赶脚)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 学会写注释"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python中的注释有单行注释和多行注释：\n",
    "\n",
    "__单行注释__以 # 开头，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print('hello,word')  呜呜呜，我被注释了\n",
    "print('hello,world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__多行注释__用三个单引号 ''' 或者三个双引号 \"\"\" 将注释括起来，例如:\n",
    "\n",
    "1、使用3个单引号（'''）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/python3 \n",
    "'''\n",
    "这是多行注释，用三个单引号\n",
    "这是多行注释，用三个单引号 \n",
    "这是多行注释，用三个单引号\n",
    "'''\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2、使用三个双引号（\"\"\"）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/python3 \n",
    "\"\"\"\n",
    "这是多行注释，用三个双引号\n",
    "这是多行注释，用三个双引号 \n",
    "这是多行注释，用三个双引号\n",
    "\"\"\"\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从数字开始"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整数（比如 2、4、20 ）有 `int` 类型，有小数部分的（比如 5.0、1.6 ）有 `float` 类型。在这个手册的后半部分我们会看到更多的数值类型。\n",
    "\n",
    "除法运算 (`/ `) 永远返回浮点数类型。如果要做 floor division 得到一个整数结果（忽略小数部分）你可以使用` // ` 运算符；如果要计算余数，可以使用`%`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.083333333333332"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(15*16-13+14)/12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.25"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9//4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以使用 ** 运算符来计算乘方"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还记得复数吗，Python 也内置对 [复数](https://docs.python.org/zh-cn/3.7/library/stdtypes.html#typesnumeric) 的支持，使用后缀 j 或者 J 就可以表示虚数部分（奇怪的东西）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4+6j)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1+2j) + (3+4J)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "python字符串有多种形式，可以使用单引号（'……'），双引号（\"……\"）都可以获得同样的结果。反斜杠 \\ 可以用来转义(防止一些特殊字符在字符串外侧引号影响下不正常的显示):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I hava a pen\n"
     ]
    }
   ],
   "source": [
    "'I hava a pen'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'world'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I hava an apple\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\"Yes,\" he hava a pen.'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\\"Yes,\\\" he hava a pen.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Isn't,\" they said.\n"
     ]
    }
   ],
   "source": [
    "print('\"Isn\\'t,\" they said.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "直接在通过解释器输出的字符串外面会加上引号，特殊字符会使用反斜杠来转义。虽然有时这看起来会与输入不一样（外面所加的引号可能会改变），但两个字符串本质是相同的。如果字符串中有单引号而没有双引号，该字符串外将加双引号来表示，否则就用单引号。print()函数会生成可读性更强的输出，即略去两边的引号，并且打印出经过转义的特殊字符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你不希望前置了 \\ 的字符转义成特殊字符，可以使用 原始字符串 方式，在引号前添加 r 即可（推荐）:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:\\some\\dic\n"
     ]
    }
   ],
   "source": [
    "print(r'D:\\some\\dic')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有时候字符串很长，出于良好的代码规范不能让一行代码太长，字符串字面值可以跨行连续输入。一种方式是用三重引号：```\"\"\"...\"\"\"``` 或 ```'''...'''```。字符串中的回车换行会自动包含到字符串中，如果不想包含，在行尾添加一个 \\ 即可。如下例:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a long  \n",
      "  and unregular string! \n",
      "      you can print every thing here~ ,even the space.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"\\\n",
    "this is a long  \n",
    "  and unregular string! \n",
    "      you can print every thing here~ ,even the space.\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串可以用 + 进行连接（粘到一起），__也可以用 * 进行重复:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hahaha  yo~'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * 'ha' +\"  \"+ 'yo~'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串支持直接拼接,只能对字面值这样操作，变量或表达式不行():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'like this'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'like'' ''this'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-75-7efcf68c78a5>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-75-7efcf68c78a5>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    ('h' * 3) 'yo~'\u001b[0m\n\u001b[1;37m                  ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# error\n",
    "('h' * 3) 'yo~'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你想连接变量，或者连接变量和字面值，可以用 + 号:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'http://www.example.com'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#先申明个变量\n",
    "prefix =r'http://'\n",
    "prefix + 'www.example.com'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还记得C语言的数组吗，给它个索引下标(从0开始)它就返回了对应的值，字符串也是可以被 索引 （下标访问）的，第一个字符索引是 0。单个字符并没有特殊的类型，只是一个长度为一的字符串:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word = 'Python'\n",
    "word[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了索引，字符串还支持 *切片*。索引可以得到单个字符，而 *切片* 可以获取子字符串:注意切片的开始总是被包括在结果中，而结束不被包括。这使得 s[:i] + s[i:] 总是等于 s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Py\n",
      "thon\n",
      "t\n"
     ]
    }
   ],
   "source": [
    "print(word[:2])\n",
    "print(word[2:])\n",
    "print(word[2:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片的索引有默认值；省略开始索引时默认为0，省略结束索引时默认为到字符串的结束,越界索引会被自动处理:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[:23]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pyth'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "妄图通过索引来改变字符串是不行哒,像这样:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'word' 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-20-e8300666ad90>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mword\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;34m'jiaoyi'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'word' is not defined"
     ]
    }
   ],
   "source": [
    "word[2:]='jiaoyi'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "自带的函数`len()`可以返回一个字符串的长度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 中可以通过组合一些类型的值得到多种 *复合* 数据类型。其中最常用的 *列表* ，可以通过方括号括起、逗号分隔的一组值得到。一个 *列表* 可以包含不同类型的元素，但通常使用时各个元素类型相同:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [1,1,2,3,5,8,13]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表也能*切片*，所有的切片操作都返回一个新列表，这个新列表包含所需要的元素。就是说，如下的切片会返回列表的一个新的浅拷贝(深拷贝和浅拷贝是较高阶内容，先不用纠结，但是很重要,感兴趣可以去学习[这篇文章](https://www.jianshu.com/p/5cf2aebdf7c5))，以及[这里](http://www.baidu.com):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "new_squares = squares[:3]\n",
    "print(new_squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 3, 5, 8, 13]\n",
      "[1, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "squares[1]=2\n",
    "print(squares)\n",
    "print(new_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表是一个可变(mutable)类型，就是说它可以改变自己的内容（你真的理解了吗？）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 3]\n"
     ]
    }
   ],
   "source": [
    "list_1 = [1,2,3]\n",
    "list_1[1]=1\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片是个好东西，浅拷贝的性质和加上列表是个可变对象，可以改变切片出来的东西，被切的列表也改变了，就像做手术一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "letters[2:5] = ['C', 'D', 'E']\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和字符串一样，也有`len()`方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "嵌套列表（二维数组）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['a', 'b', 'c']\n",
    "n = [1, 2, 3]\n",
    "x = [a, n]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 那就开始编程吧"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以编写 斐波那契数列 的初始子序列，如下所示:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "a ,b=0 , 1\n",
    "while a<10:\n",
    "    print(a)\n",
    "    a , b = b,a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一行含有一个 多重赋值: 变量 a 和 b 同时得到了新值 0 和 1. 最后一行又用了一次多重赋值, 这体现出了右手边的表达式，在任何赋值发生之前就被求值了。右手边的表达式是从左到右被求值的。\n",
    "\n",
    "while 循环只要它的条件（这里指： a < 10）保持为真就会一直执行。Python 和 C 一样，任何非零整数都为真；零为假。这个条件也可以是字符串或是列表的值，事实上任何序列都可以；长度非零就为真，空序列就为假。在这个例子里，判断条件是一个简单的比较。标准的比较操作符的写法和 C 语言里是一样： < （小于）、 > （大于）、 == （等于）、 <= （小于或等于)、 >= （大于或等于）以及 != （不等于）。\n",
    "\n",
    "循环体 是 __缩进__的 ：__缩进__是 Python 组织语句的方式，用以取代其它语言中常见的行末`;`,以及绝大多数的`{}`。在交互式命令行里，你得给每个缩进的行敲下 Tab 键或者（多个，一般是4个）空格键。实际上用文本编辑器的话，你要准备更复杂的输入方式；所有像样的文本编辑器都有自动缩进的设置。交互式命令行里，当一个组合的语句输入时, 需要在最后敲一个空行表示完成（因为语法分析器猜不出来你什么时候打的是最后一行）。注意，在同一块语句中的每一行，都要缩进相同的长度。\n",
    "\n",
    "`print()` 函数将所有传进来的参数值打印出来，`print()`处理多个参数，包括浮点数，字符串。字符串打印出来不带引号, 并且在参数项之间会插入一个空格,这样你就可以很好的把东西格式化,像这样:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of i is 65536\n",
      "tom is good man,but I ...\n"
     ]
    }
   ],
   "source": [
    "i = 256*256\n",
    "print('The value of i is',i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关键字参数 end 可以用来取消输出后面的换行, 或是用另外一个字符串来结尾:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
     ]
    }
   ],
   "source": [
    "a, b = 0, 1\n",
    "while a < 1000:\n",
    "    print(a,end =',')\n",
    "    a,b = b ,a + b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tom is nice, but I ...\n"
     ]
    }
   ],
   "source": [
    "# 格式化是更高级的字符串打印方法，这在输出日志时常用\n",
    "name = 'tom'  \n",
    "print('{} is nice, but I ...'.format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;  \n",
    "<h2 style='color:#d34ddd'>基础介绍差不多就到这里吧，入门了吗，嘻嘻~</h2>  \n",
    "\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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}