theory/python/eyes/6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第六章 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 函数的定义及调用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.1 为什么要用函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1、提高代码复用性——抽象出来，封装为函数   \n",
    "  \n",
    "2、将复杂的大问题分解成一系列小问题，分而治之——模块化设计的思想  \n",
    "  \n",
    "3、利于代码的维护和管理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**顺序式**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "2432902008176640000\n"
     ]
    }
   ],
   "source": [
    "# 5的阶乘\n",
    "n = 5\n",
    "res = 1\n",
    "for i in range(1, n+1):\n",
    "    res *= i\n",
    "print(res)\n",
    "\n",
    "# 20的阶乘\n",
    "n = 20\n",
    "res = 1\n",
    "for i in range(1, n+1):\n",
    "    res *= i\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**抽象成函数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "2432902008176640000\n"
     ]
    }
   ],
   "source": [
    "def factoria(n):\n",
    "    res = 1\n",
    "    for i in range(1,n+1):\n",
    "        res *= i\n",
    "    return res\n",
    "\n",
    "\n",
    "print(factoria(5))\n",
    "print(factoria(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.2 函数的定义及调用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**白箱子：输入——处理——输出**   \n",
    "  \n",
    "**三要素：参数、函数体、返回值**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、定义** \n",
    "  \n",
    "def&nbsp; 函数名（参数）：\n",
    "  \n",
    "&emsp;  函数体  \n",
    "  \n",
    "&emsp;  return 返回值\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 求正方形的面积\n",
    "def area_of_square(length_of_side):\n",
    "    square_area = pow(length_of_side, 2)\n",
    "    return square_area    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、调用**  \n",
    "  \n",
    "函数名（参数）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area = area_of_square(5)\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.3 参数传递"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**0、形参与实参**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 形参（形式参数）：函数定义时的参数，实际上就是变量名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 实参（实际参数）：函数调用时的参数，实际上就是变量的值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、位置参数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 严格按照位置顺序，用实参对形参进行赋值(关联）  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 一般用在参数比较少的时候"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "def function(x, y, z):\n",
    "    print(x, y, z)\n",
    "    \n",
    "    \n",
    "function(1, 2, 3)    # x = 1; y = 2; z = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 实参与形参个数必须一一对应，一个不能多，一个不能少"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "function() missing 1 required positional argument: 'z'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-2a7da6ff9675>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\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[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: function() missing 1 required positional argument: 'z'"
     ]
    }
   ],
   "source": [
    "function(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "function() takes 3 positional arguments but 4 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-748d3d0335e6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\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[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: function() takes 3 positional arguments but 4 were given"
     ]
    }
   ],
   "source": [
    "function(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、关键字参数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 打破位置限制，直呼其名的进行值的传递（形参=实参）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 必须遵守实参与形参数量上一一对应"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 多用在参数比较多的场合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 1 2\n"
     ]
    }
   ],
   "source": [
    "def function(x, y, z):\n",
    "    print(x, y, z)\n",
    "    \n",
    "    \n",
    "function(y=1, z=2, x=3)    # x = 1; y = 2; z = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 位置参数可以与关键字参数混合使用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 但是，位置参数必须放在关键字参数前面"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 2\n"
     ]
    }
   ],
   "source": [
    "function(1, z=2, y=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "function(1, 2, z=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 不能为同一个形参重复传值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "function() got multiple values for argument 'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-f385272db011>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mz\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\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: function() got multiple values for argument 'x'"
     ]
    }
   ],
   "source": [
    "def function(x, y, z):\n",
    "    print(x, y, z)\n",
    "\n",
    "\n",
    "function(1, z=2, x=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、默认参数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 在定义阶段就给形参赋值——该形参的常用值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 在定义阶段就给形参赋值——该形参的常用值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **默认参数必须放在非默认参数后面**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **调用函数时，可以不对该形参传值**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 机器学习库中类的方法里非常常见"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "大杰仔 18 male\n"
     ]
    }
   ],
   "source": [
    "def register(name, age, sex=\"male\"):\n",
    "    print(name, age, sex)\n",
    "\n",
    "\n",
    "register(\"大杰仔\", 18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 也可以按正常的形参进行传值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "林志玲 38 female\n"
     ]
    }
   ],
   "source": [
    "register(\"林志玲\", 38, \"female\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 默认参数应该设置为不可变类型（数字、字符串、元组）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1759752744328\n",
      "1759752744328\n",
      "[1]\n"
     ]
    }
   ],
   "source": [
    "def function(ls=[]):\n",
    "    print(id(ls))\n",
    "    ls.append(1)\n",
    "    print(id(ls))\n",
    "    print(ls)\n",
    "\n",
    "\n",
    "function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1759752744328\n",
      "1759752744328\n",
      "[1, 1]\n"
     ]
    }
   ],
   "source": [
    "function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1759752744328\n",
      "1759752744328\n",
      "[1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1759701700656\n",
      "1759754352240\n",
      "Python3.7\n"
     ]
    }
   ],
   "source": [
    "def function(ls=\"Python\"):\n",
    "    print(id(ls))\n",
    "    ls += \"3.7\"\n",
    "    print(id(ls))\n",
    "    print(ls)\n",
    "    \n",
    "    \n",
    "function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1759701700656\n",
      "1759754353328\n",
      "Python3.7\n"
     ]
    }
   ],
   "source": [
    "function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1759701700656\n",
      "1759754354352\n",
      "Python3.7\n"
     ]
    }
   ],
   "source": [
    "function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **让参数变成可选的**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "大仔\n",
      "大杰仔\n"
     ]
    }
   ],
   "source": [
    "def name(first_name, last_name, middle_name=None):\n",
    "    if middle_name:\n",
    "        return first_name+middle_name+last_name\n",
    "    else:\n",
    "        return first_name+last_name\n",
    "    \n",
    "    \n",
    "print(name(\"大\",\"仔\"))\n",
    "print(name(\"大\", \"仔\", \"杰\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4、可变长参数&emsp;*args**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 不知道会传过来多少参数  *args  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 该形参必须放在参数列表的最后"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "(4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "def foo(x, y, z, *args):\n",
    "    print(x, y ,z)\n",
    "    print(args)\n",
    "    \n",
    "    \n",
    "foo(1, 2, 3, 4, 5, 6)    # 多余的参数，打包传递给args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 实参打散"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "([4, 5, 6],)\n"
     ]
    }
   ],
   "source": [
    "def foo(x, y, z, *args):\n",
    "    print(x, y ,z)\n",
    "    print(args)\n",
    "\n",
    "    \n",
    "foo(1, 2, 3, [4, 5, 6])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "(4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "foo(1, 2, 3, *[4, 5, 6])   # 打散的是列表、字符串、元组或集合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5、可变长参数&emsp;****kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "{'a': 4, 'b': 5, 'c': 6}\n"
     ]
    }
   ],
   "source": [
    "def foo(x, y, z, **kwargs):\n",
    "    print(x, y ,z)\n",
    "    print(kwargs)\n",
    "    \n",
    "    \n",
    "foo(1, 2, 3, a=4, b=5, c=6)    #  多余的参数，以字典的形式打包传递给kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 字典实参打散"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "{'a': 4, 'b': 5, 'c': 6}\n"
     ]
    }
   ],
   "source": [
    "def foo(x, y, z, **kwargs):\n",
    "    print(x, y ,z)\n",
    "    print(kwargs)\n",
    "\n",
    "    \n",
    "foo(1, 2, 3, **{\"a\": 4, \"b\": 5, \"c\":6})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **可变长参数的组合使用**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "{'a': 4, 'b': 5, 'c': 6}\n"
     ]
    }
   ],
   "source": [
    "def foo(*args, **kwargs):\n",
    "    print(args)\n",
    "    print(kwargs)\n",
    "    \n",
    "    \n",
    "foo(1, 2, 3, a=4, b=5, c=6) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.4 函数体与变量作用域"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 函数体就是一段只在函数被调用时，才会执行的代码，代码构成与其他代码并无不同  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **局部变量**——仅在函数体内定义和发挥作用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'z' 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-29-9a7fd4c4c0a9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mmultipy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m9\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m)\u001b[0m            \u001b[1;31m# 函数执行完毕，局部变量z已经被释放掉了\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'z' is not defined"
     ]
    }
   ],
   "source": [
    "def multipy(x, y):\n",
    "    z = x*y\n",
    "    return z   \n",
    "\n",
    "\n",
    "multipy(2, 9)\n",
    "print(z)            # 函数执行完毕，局部变量z已经被释放掉了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **全局变量**——外部定义的都是全局变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 全局变量可以在函数体内直接被使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 54]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 3\n",
    "ls = [0]\n",
    "def multipy(x, y):\n",
    "    z = n*x*y\n",
    "    ls.append(z)\n",
    "    return z   \n",
    "\n",
    "\n",
    "print(multipy(2, 9))\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 通过global 在函数体内定义全局变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "def multipy(x, y):\n",
    "    global z\n",
    "    z = x*y\n",
    "    return z \n",
    "\n",
    "\n",
    "print(multipy(2, 9))\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.5 返回值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、单个返回值**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo(x):\n",
    "    return x**2\n",
    "\n",
    "\n",
    "res = foo(10)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、多个返回值**——以元组的形式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 9, 27)\n"
     ]
    }
   ],
   "source": [
    "def foo(x):\n",
    "    return 1, x, x**2, x**3    # 逗号分开，打包返回\n",
    "\n",
    "\n",
    "print(foo(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "9\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "a, b , c, d = foo(3)       # 解包赋值\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、可以有多个return 语句，一旦其中一个执行，代表了函数运行的结束**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is holiday\n",
      "Not holiday\n"
     ]
    }
   ],
   "source": [
    "def is_holiday(day):\n",
    "    if day in [\"Sunday\", \"Saturday\"]:\n",
    "        return \"Is holiday\"\n",
    "    else:\n",
    "        return \"Not holiday\"\n",
    "    print(\"啦啦啦德玛西亚，啦啦啦啦\")       # 你丫根本没机会运行。。。\n",
    "    \n",
    "    \n",
    "print(is_holiday(\"Sunday\"))\n",
    "print(is_holiday(\"Monday\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4、没有return语句，返回值为None**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我是孙悟空\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    print(\"我是孙悟空\")\n",
    "\n",
    "res = foo()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.6 几点建议"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、函数及其参数的命名参照变量的命名**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 字母小写及下划线组合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 有实际意义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、应包含简要阐述函数功能的注释，注释紧跟函数定义后面**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    # 这个函数的作用是为了给大家瞅一瞅，你瞅啥，瞅你咋地。。。。\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、函数定义前后各空两行**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1():\n",
    "    pass\n",
    "\n",
    "                 # 空出两行，以示清白\n",
    "def f2():\n",
    "    pass\n",
    "\n",
    "\n",
    "def f3(x=3):    # 默认参数赋值等号两侧不需加空格\n",
    "    pass\n",
    "\n",
    "\n",
    "# ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4、默认参数赋值等号两侧不需加空格**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 函数式编程实例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**模块化编程思想**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 自顶向下，分而治之"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**【问题描述】**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 小丹和小伟羽毛球打的都不错，水平也在伯仲之间，小丹略胜一筹，基本上，打100个球，小丹能赢55次，小伟能赢45次。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 但是每次大型比赛（1局定胜负，谁先赢到21分，谁就获胜），小丹赢的概率远远大于小伟，小伟很是不服气。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **亲爱的小伙伴，你能通过模拟实验，来揭示其中的奥妙吗？**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**【问题抽象】**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1、在小丹Vs小伟的二元比赛系统中，小丹每球获胜概率55%，小伟每球获胜概率45%；  \n",
    "  \n",
    "2、每局比赛，先赢21球（21分）者获胜；  \n",
    "  \n",
    "3、假设进行n = 10000局独立的比赛，小丹会获胜多少局？（n 较大的时候，实验结果≈真实期望）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**【问题分解】**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    # 主要逻辑\n",
    "    prob_A, prob_B, number_of_games = get_inputs()                        # 获取原始数据\n",
    "    win_A, win_B = sim_n_games(prob_A, prob_B, number_of_games)           # 获取模拟结果\n",
    "    print_summary(win_A, win_B, number_of_games)                          # 结果汇总输出"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、输入原始数据**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_inputs():  \n",
    "    # 输入原始数据\n",
    "    prob_A = eval(input(\"请输入运动员A的每球获胜概率(0~1)：\"))\n",
    "    prob_B = round(1-prob_A, 2)\n",
    "    number_of_games = eval(input(\"请输入模拟的场次（正整数）：\"))\n",
    "    print(\"模拟比赛总次数：\", number_of_games)\n",
    "    print(\"A 选手每球获胜概率：\", prob_A)\n",
    "    print(\"B 选手每球获胜概率：\", prob_B)\n",
    "    return prob_A, prob_B, number_of_games"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**&emsp;&emsp;单元测试**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "请输入运动员A的每球获胜概率(0~1)：0.55\n",
      "请输入模拟的场次（正整数）：10000\n",
      "模拟比赛总次数： 10000\n",
      "A 选手每球获胜概率： 0.55\n",
      "B 选手每球获胜概率： 0.45\n",
      "0.55 0.45 10000\n"
     ]
    }
   ],
   "source": [
    "prob_A, prob_B, number_of_games = get_inputs()\n",
    "print(prob_A, prob_B, number_of_games)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、多场比赛模拟**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sim_n_games(prob_A, prob_B, number_of_games):\n",
    "    # 模拟多场比赛的结果\n",
    "    win_A, win_B = 0, 0                # 初始化A、B获胜的场次\n",
    "    for i in range(number_of_games):   # 迭代number_of_games次\n",
    "        score_A, score_B = sim_one_game(prob_A, prob_B)  # 获得模拟依次比赛的比分\n",
    "        if score_A > score_B:\n",
    "            win_A += 1\n",
    "        else:\n",
    "            win_B += 1\n",
    "    return win_A, win_B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def sim_one_game(prob_A, prob_B):\n",
    "    # 模拟一场比赛的结果\n",
    "    score_A, score_B = 0, 0\n",
    "    while not game_over(score_A, score_B):\n",
    "        if random.random() < prob_A:                # random.random() 生产[0,1)之间的随机小数,均匀分布\n",
    "            score_A += 1                 \n",
    "        else:\n",
    "            score_B += 1\n",
    "    return score_A, score_B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def game_over(score_A, score_B):\n",
    "    # 单场模拟结束条件，一方先达到21分，比赛结束\n",
    "    return score_A == 21 or score_B == 21"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**&emsp;&emsp;单元测试 用assert——断言**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* assert expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 表达式结果为 false 的时候触发异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-42-88b651626036>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32massert\u001b[0m \u001b[0mgame_over\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m9\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m21\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32massert\u001b[0m \u001b[0mgame_over\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m11\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m8\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mgame_over\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m21\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m8\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "assert game_over(21, 8) == True   \n",
    "assert game_over(9, 21) == True\n",
    "assert game_over(11, 8) == False\n",
    "assert game_over(21, 8) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(21, 7)\n",
      "(21, 14)\n",
      "(10, 21)\n"
     ]
    }
   ],
   "source": [
    "print(sim_one_game(0.55, 0.45))\n",
    "print(sim_one_game(0.7, 0.3))\n",
    "print(sim_one_game(0.2, 0.8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(731, 269)\n"
     ]
    }
   ],
   "source": [
    "print(sim_n_games(0.55, 0.45, 1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、结果汇总输出**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_summary(win_A, win_B, number_of_games):\n",
    "    # 结果汇总输出\n",
    "    print(\"共模拟了{}场比赛\".format(number_of_games))\n",
    "    print(\"选手A获胜{0}场，占比{1:.1%}\".format(win_A, win_A/number_of_games))\n",
    "    print(\"选手B获胜{0}场，占比{1:.1%}\".format(win_B, win_B/number_of_games))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共模拟了1000场比赛\n",
      "选手A获胜729场，占比72.9%\n",
      "选手B获胜271场，占比27.1%\n"
     ]
    }
   ],
   "source": [
    "print_summary(729, 271, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "请输入运动员A的每球获胜概率(0~1)：0.52\n",
      "请输入模拟的场次（正整数）：10000\n",
      "模拟比赛总次数： 10000\n",
      "A 选手每球获胜概率： 0.52\n",
      "B 选手每球获胜概率： 0.48\n",
      "共模拟了10000场比赛\n",
      "\u001b[31m选手A获胜6033场，占比60.3%\n",
      "选手B获胜3967场，占比39.7%\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def get_inputs():  \n",
    "    # 输入原始数据\n",
    "    prob_A = eval(input(\"请输入运动员A的每球获胜概率(0~1)：\"))\n",
    "    prob_B = round(1-prob_A, 2)\n",
    "    number_of_games = eval(input(\"请输入模拟的场次（正整数）：\"))\n",
    "    print(\"模拟比赛总次数：\", number_of_games)\n",
    "    print(\"A 选手每球获胜概率：\", prob_A)\n",
    "    print(\"B 选手每球获胜概率：\", prob_B)\n",
    "    return prob_A, prob_B, number_of_games\n",
    "\n",
    "\n",
    "def game_over(score_A, score_B):\n",
    "    # 单场模拟结束条件，一方先达到21分，比赛结束    \n",
    "    return score_A == 21 or score_B == 21\n",
    "\n",
    "\n",
    "def sim_one_game(prob_A, prob_B):\n",
    "    # 模拟一场比赛的结果\n",
    "    score_A, score_B = 0, 0\n",
    "    while not game_over(score_A, score_B):\n",
    "        if random.random() < prob_A:                # random.random() 生产[0,1)之间的随机小数,均匀分布\n",
    "            score_A += 1                 \n",
    "        else:\n",
    "            score_B += 1\n",
    "    return score_A, score_B\n",
    "\n",
    "\n",
    "def sim_n_games(prob_A, prob_B, number_of_games):\n",
    "    # 模拟多场比赛的结果\n",
    "    win_A, win_B = 0, 0                # 初始化A、B获胜的场次\n",
    "    for i in range(number_of_games):   # 迭代number_of_games次\n",
    "        score_A, score_B = sim_one_game(prob_A, prob_B)  # 获得模拟依次比赛的比分\n",
    "        if score_A > score_B:\n",
    "            win_A += 1\n",
    "        else:\n",
    "            win_B += 1\n",
    "    return win_A, win_B\n",
    "\n",
    "\n",
    "def print_summary(win_A, win_B, number_of_games):\n",
    "    # 结果汇总输出\n",
    "    print(\"共模拟了{}场比赛\".format(number_of_games))\n",
    "    print(\"\\033[31m选手A获胜{0}场，占比{1:.1%}\".format(win_A, win_A/number_of_games))\n",
    "    print(\"选手B获胜{0}场，占比{1:.1%}\".format(win_B, win_B/number_of_games))\n",
    "    \n",
    "\n",
    "def main():\n",
    "    # 主要逻辑\n",
    "    prob_A, prob_B, number_of_games = get_inputs()                        # 获取原始数据\n",
    "    win_A, win_B = sim_n_games(prob_A, prob_B, number_of_games)           # 获取模拟结果\n",
    "    print_summary(win_A, win_B, number_of_games)                          # 结果汇总输出\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经统计，小丹跟小伟14年职业生涯，共交手40次，小丹以28:12遥遥领先。 \n",
    "  \n",
    "其中，两人共交战整整100局：  \n",
    "  \n",
    "小丹获胜61局，占比61%；  \n",
    "  \n",
    "小伟获胜39局，占比39%。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 你以为你跟别人的差距只是一点点，实际上，差距老大了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 匿名函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、基本形式**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lambda 变量: 函数体"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、常用用法**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在参数列表中最适合使用匿名函数，尤其是与key = 搭配"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 排序sort()  sorted()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(76, 94), (79, 100), (85, 85), (86, 71), (93, 88)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [(93, 88), (79, 100), (86, 71), (85, 85), (76, 94)]\n",
    "ls.sort()\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(86, 71), (85, 85), (93, 88), (76, 94), (79, 100)]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls.sort(key = lambda x: x[1])\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(93, 88), (79, 100), (85, 85), (76, 94), (86, 71)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [(93, 88), (79, 100), (86, 71), (85, 85), (76, 94)]\n",
    "temp = sorted(ls, key = lambda x: x[0]+x[1], reverse=True)\n",
    "temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* max() min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(79, 100)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [(93, 88), (79, 100), (86, 71), (85, 85), (76, 94)]\n",
    "n = max(ls, key = lambda x: x[1])\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(86, 71)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = min(ls, key = lambda x: x[1])\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 面向过程和面向对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**面向过程**——以过程为中心的编程思想，以“什么正在发生”为主要目标进行编程。&emsp;**冰冷的，程序化的**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**面向对象**——将现实世界的事物抽象成对象，更关注“谁在受影响”，更加贴近现实。 &ensp;**有血有肉，拟人（物）化的** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **以公共汽车为例**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**“面向过程”**：汽车启动是一个事件，汽车到站是另一个事件。。。。\n",
    "  \n",
    "在编程序的时候我们关心的是某一个事件，而不是汽车本身。 \n",
    "  \n",
    "我们分别对启动和到站编写程序。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**\"面向对象\"**：构造“汽车”这个对象。  \n",
    "  \n",
    "对象包含动力、服役时间、生产厂家等等一系列的“属性”；  \n",
    "  \n",
    "也包含加油、启动、加速、刹车、拐弯、鸣喇叭、到站、维修等一系列的“方法”。  \n",
    "  \n",
    "通过对象的行为表达相应的事件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}