02_Function/02_function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际工作生活中，不少初学者编写的 Python 程序，他们长达几百行的代码中，却没有一个函数，通通按顺序堆到一块儿，不仅让人读起来费时费力，往往也是错误连连。一个规范的值得借鉴的 Python 程序，除非代码量很少（比如 10 行、20 行以下），**理应由多个函数组成**，这样的代码才更加模块化、规范化。函数是 Python 程序中不可或缺的一部分。事实上，在前面的学习中，我们已经用到了很多 Python 的内置函数，比如 sorted() 表示对一个集合序列排序，len() 表示返回一个集合序列的长度大小等等。这节课，我们主要来学习 Python 的自定义函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数基础\n",
    "那么，到底什么是函数，如何在 Python 程序中定义函数呢？说白了，函数就是为了实现某一功能的代码段，只要写好以后，就可以重复利用。我们先来看下面一个简单的例子:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got a message: Hello World\n"
     ]
    }
   ],
   "source": [
    "def my_func(message):\n",
    "    print('Got a message: {}'.format(message))\n",
    "\n",
    "# 调用函数 my_func()\n",
    "my_func('Hello World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `def` 是函数的声明；\n",
    "- `my_func` 是函数的名称；\n",
    "- 括号里面的 `message` 则是函数的参数；\n",
    "- `print` 那行则是函数的主体部分，可以执行相应的语句；\n",
    "- 在函数最后，你可以返回调用结果 `return 或 yield`，也可以不返回\n",
    "\n",
    "总结一下，可以抽象成如下形式：\n",
    "```\n",
    "def name(param1, param2, ..., paramN):\n",
    "    statements\n",
    "    return/yield value # optional\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def my_sum(a, b):\n",
    "    return a + b\n",
    "\n",
    "result = my_sum(3, 5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面代码定义了 `my_sum()` 这个函数，它有两个参数 a 和 b，作用是相加；\n",
    "\n",
    "随后，调用 `my_sum()` 函数，分别把 3 和 5 赋于 a 和 b；\n",
    "\n",
    "最后，返回其相加的值，赋于变量 result，并输出得到 8。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "largest element is: 8\n"
     ]
    }
   ],
   "source": [
    "def find_largest_element(l):\n",
    "    if not isinstance(l, list):\n",
    "        print('input is not type of list')\n",
    "        return\n",
    "    if len(l) == 0:\n",
    "        print('empty input')\n",
    "        return\n",
    "    largest_element = l[0]\n",
    "    for item in l:\n",
    "        if item > largest_element:\n",
    "            largest_element = item\n",
    "    print('largest element is: {}'.format(largest_element)) \n",
    "      \n",
    "find_largest_element([8, 1,-3, 2, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个例子中，我们定义了函数 `find_largest_element(l)`，作用是遍历输入的列表，找出最大的值并打印。\n",
    "\n",
    "因此，当我们调用它，并传递列表 `[8, 1, -3, 2, 0]` 作为参数时，程序就会输出 `largest element is: 8`。\n",
    "\n",
    "需要注意，**主程序调用函数时，必须保证这个函数此前已经定义过**，不然就会报错，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got a message: hello world\n"
     ]
    }
   ],
   "source": [
    "my_func('hello world')\n",
    "def my_func(message):\n",
    "    print('Got a message: {}'.format(message))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是，如果我们在函数内部调用其他函数，函数间哪个声明在前、哪个在后就无所谓，因为 def 是可执行语句，函数在调用之前都不存在，我们只需保证调用时，所需的函数都已经声明定义："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got a message: hello world\n"
     ]
    }
   ],
   "source": [
    "def my_func(message):\n",
    "    my_sub_func(message)  # 调用my_sub_func()在其声明之前不影响程序执行\n",
    "    \n",
    "def my_sub_func(message):\n",
    "    print('Got a message: {}'.format(message))\n",
    "\n",
    "my_func('hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 函数的参数可以设定默认值，比如下面这样的写法：\n",
    "```\n",
    "def func(param = 0):\n",
    "    ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样，在调用函数 `func()` 时，如果参数 `param` 没有传入，则参数默认为 0；而如果传入了参数 `param`，其就会覆盖默认值。\n",
    "\n",
    "Python 和其他语言相比的一大特点是，Python 是 `dynamically typed` 的，可以接受任何数据类型（整型，浮点，字符串等等）。对函数参数来说，这一点同样适用。比如还是刚刚的 `my_sum` 函数，我们也可以把列表作为参数来传递，表示将两个列表相连接："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(my_sum([1, 2], [3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样，也可以把字符串作为参数传递，表示字符串的合并拼接："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print(my_sum('hello ', 'world'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，如果两个参数的数据类型不同，比如一个是列表、一个是字符串，两者无法相加，那就会报错："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"str\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-0e8e061ebc5a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_sum\u001b[0m\u001b[1;33m(\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;34m'hello'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-5-98cb9f9b2abb>\u001b[0m in \u001b[0;36mmy_sum\u001b[1;34m(a, b)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmy_sum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmy_sum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate list (not \"str\") to list"
     ]
    }
   ],
   "source": [
    "print(my_sum([1, 2], 'hello'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "发生错误!unsupported operand type(s) for +: 'int' and 'str'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    my_sum(5, \"7\")\n",
    "except Exception as err:\n",
    "    print(\"发生错误!{}\".format(err))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以看到，`Python` 不用考虑输入的数据类型，而是将其交给具体的代码去判断执行，同样的一个函数（比如这边的相加函数 `my_sum()`），可以同时应用在整型、列表、字符串等等的操作中。\n",
    "\n",
    "在编程语言中，我们把这种行为称为**多态**。这也是 Python 和其他语言，比如 Java、C 等很大的一个不同点。当然，Python 这种方便的特性，在实际使用中也会带来诸多问题。因此，**必要时请你在开头加上数据的类型检查**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 函数的另一大特性，是 Python 支持函数的嵌套。所谓的函数嵌套，就是指函数里面又有函数，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "def f1():\n",
    "    print('hello')\n",
    "    def f2():\n",
    "        print('world')\n",
    "    f2()\n",
    "f1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里函数 `f1()` 的内部，又定义了函数 `f2()`。在调用函数 `f1()` 时，会先打印字符串'hello'，然后 `f1()` 内部再调用 `f2()`，打印字符串'world'。你也许会问，为什么需要函数嵌套？这样做有什么好处呢？\n",
    "\n",
    "其实，函数的嵌套，主要有下面两个方面的作用：\n",
    "- 第一，函数的嵌套能够保证内部函数的隐私。\n",
    "- 第二，合理的使用函数嵌套，能够提高程序的运行效率。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "内部函数只能被外部函数所调用和访问，不会暴露在全局作用域，因此，如果你的函数内部有一些隐私数据（比如数据库的用户、密码等），不想暴露在外，那你就可以使用函数的的嵌套，将其封装在内部函数中，只通过外部函数来访问。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def connect_DB():\n",
    "    def get_DB_configuration():\n",
    "        ...\n",
    "        return host, username, password\n",
    "    conn = connector.connect(get_DB_configuration())\n",
    "    return conn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的函数 `get_DB_configuration()`，便是内部函数，它无法在 `connect_DB()` 函数以外被单独调用。也就是说，下面这样的外部直接调用是错误的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'get_DB_configuration' 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-14-252083049dab>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mget_DB_configuration\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'get_DB_configuration' is not defined"
     ]
    }
   ],
   "source": [
    "get_DB_configuration()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们只能通过调用外部函数 `connect_DB()` 来访问它，这样一来，程序的安全性便有了很大的提高。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二，合理的使用函数嵌套，能够提高程序的运行效率。我们来看下面这个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 函数嵌套提高效率\n",
    "def factorial(input):\n",
    "    # validation check\n",
    "    # 输入检查，只运行一次\n",
    "    if not isinstance(input, int):\n",
    "        raise Exception('input must be an integer.')\n",
    "    if input < 0:\n",
    "        raise Exception('input must be greater or equal to 0' )\n",
    "\n",
    "    # 实际计算\n",
    "    def inner_factorial(input):\n",
    "        if input <= 1:\n",
    "            return 1\n",
    "        return input * inner_factorial(input-1)\n",
    "    return inner_factorial(input)\n",
    "\n",
    "try:\n",
    "    print(factorial(12))\n",
    "except Exception as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里，我们使用递归的方式计算一个数的阶乘。因为在计算之前，需要检查输入是否合法，所以我写成了函数嵌套的形式，这样一来，输入是否合法就只用检查一次。而如果我们不使用函数嵌套，那么每调用一次递归便会检查一次，这是没有必要的，也会降低程序的运行效率。\n",
    "\n",
    "实际工作中，如果你遇到相似的情况，输入检查不是很快，还会耗费一定的资源，那么运用函数的嵌套就十分必要了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数变量作用域\n",
    "\n",
    "Python 函数中变量的作用域和其他语言类似。如果变量是在函数内部定义的，就称为局部变量，只在函数内部有效。一旦函数执行完毕，局部变量就会被回收，无法访问，比如下面的例子：\n",
    "```\n",
    "def read_text_from_file(file_path):\n",
    "    with open(file_path) as file:\n",
    "        ...\n",
    "```\n",
    "我们在函数内部定义了 file 这个变量，这个变量只在 `read_text_from_file()` 这个函数里有效，在函数外部则无法访问。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相对应的，全局变量则是定义在整个文件层次上的，比如下面这段代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "MIN_VALUE = 1  # 全局变量\n",
    "MAX_VALUE = 10  # 全局变量\n",
    "\n",
    "def validation_check(value):\n",
    "    if value < MIN_VALUE or value > MAX_VALUE:\n",
    "        raise Exception('validation check fails')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的 `MIN_VALUE` 和 `MAX_VALUE` 就是全局变量，可以在文件内的任何地方被访问，当然在函数内部也是可以的。\n",
    "\n",
    "不过，**我们不能在函数内部随意改变全局变量的值**。比如，下面的写法就是错误的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'MIN_VALUE' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-f3947a057b16>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mMIN_VALUE\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mvalidation_check\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-16-f3947a057b16>\u001b[0m in \u001b[0;36mvalidation_check\u001b[1;34m(value)\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;32mdef\u001b[0m \u001b[0mvalidation_check\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[0mMIN_VALUE\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mvalidation_check\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'MIN_VALUE' referenced before assignment"
     ]
    }
   ],
   "source": [
    "MIN_VALUE = 1\n",
    "MAX_VALUE = 10\n",
    "\n",
    "def validation_check(value):\n",
    "    MIN_VALUE += 1\n",
    "\n",
    "validation_check(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是因为，`Python` 的解释器会默认函数内部的变量为局部变量，但是又发现局部变量 `MIN_VALUE` 并没有声明，因此就无法执行相关操作。所以，如果我们一定要在函数内部改变全局变量的值，就必须加上 `global` 这个声明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# 函数中改变外部变量\n",
    "MIN_VALUE = 1\n",
    "MAX_VALUE = 10\n",
    "\n",
    "def validation_check(value):\n",
    "    global MIN_VALUE\n",
    "    MIN_VALUE += 1\n",
    "    print(MIN_VALUE)\n",
    "    \n",
    "validation_check(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的 `global` 关键字，并不表示重新创建了一个全局变量 `MIN_VALUE`，而是告诉 Python 解释器，函数内部的变量 MIN_VALUE，就是之前定义的全局变量，并不是新的全局变量，也不是局部变量。这样，程序就可以在函数内部访问全局变量，并修改它的值了。\n",
    "\n",
    "另外，**如果遇到函数内部局部变量和全局变量同名的情况，那么在函数内部，局部变量会覆盖全局变量**。比如下面这种："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "MIN_VALUE = 1\n",
    "MAX_VALUE = 10\n",
    "\n",
    "def validation_check(value):\n",
    "    MIN_VALUE = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在函数 `validation_check()` 内部，我们定义了和全局变量同名的局部变量 `MIN_VALUE`，那么，`MIN_VALUE` 在函数内部的值，就应该是 3 而不是 1 了。类似的，对于嵌套函数来说，内部函数可以访问外部函数定义的变量，但是无法修改，若要修改，必须加上 nonlocal 这个关键字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner: nonlocal\n",
      "outer: nonlocal\n"
     ]
    }
   ],
   "source": [
    "# 嵌套函数内部修改，加nonlocal\n",
    "def outer():\n",
    "    x = \"local\"\n",
    "    def inner():\n",
    "        nonlocal x  # nonlocal关键字表示这里的x就是外部函数outer定义的变量x\n",
    "        x = 'nonlocal'\n",
    "        print(\"inner:\", x)\n",
    "    inner()\n",
    "    print(\"outer:\", x)\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果不加上 `nonlocal` 这个关键字，而内部函数的变量又和外部函数变量同名，那么同样的，内部函数变量会覆盖外部函数的变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner: nonlocal\n",
      "outer: local\n"
     ]
    }
   ],
   "source": [
    "def outer():\n",
    "    x = \"local\"\n",
    "    def inner():\n",
    "        x = 'nonlocal'  # 这里的x是inner这个函数的局部变量\n",
    "        print(\"inner:\", x)\n",
    "    inner()\n",
    "    print(\"outer:\", x)\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 闭包 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "闭包其实和刚刚讲的嵌套函数类似，不同的是，这里外部函数返回的是一个函数，而不是一个具体的值。返回的函数通常赋于一个变量，这个变量可以在后面被继续执行调用。举个例子你就更容易理解了。比如，我们想计算一个数的 n 次幂，用闭包可以写成下面的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nth_power(exponent):\n",
    "    def exponent_of(base):\n",
    "        return base ** exponent\n",
    "    return exponent_of  # 返回值是exponent_of函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "square = nth_power(2)  # 计算一个数的平方\n",
    "cube = nth_power(3)  # 计算一个数的立方 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print(square(2))  # 计算2的平方\n",
    "print(cube(2)) # 计算2的立方"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里外部函数 `nth_power()` 返回值，是函数 `exponent_of()`，而不是一个具体的数值。\n",
    "\n",
    "需要注意的是，在执行完 `square = nth_power(2)` 和 `cube = nth_power(3)` 后，外部函数 `nth_power()` 的参数 `exponent`，仍然会被内部函数 `exponent_of()` 记住。这样，之后我们调用 `square(2)` 或者 `cube(2)` 时，程序就能顺利地输出结果，而不会报错说参数 `exponent` 没有定义了。看到这里，你也许会思考，为什么要闭包呢？上面的程序，我也可以写成下面的形式啊！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nth_power_rewrite(base, exponent):\n",
    "    return base ** exponent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "确实可以，不过，要知道，使用闭包的一个原因，是让程序变得更简洁易读。设想一下，比如你需要计算很多个数的平方，那么你觉得写成下面哪一种形式更好呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# 不适用闭包\n",
    "res1 = nth_power_rewrite(2, 2)\n",
    "res2 = nth_power_rewrite(2, 2)\n",
    "res3 = nth_power_rewrite(2, 2)\n",
    "print(res3)\n",
    "\n",
    "# 使用闭包\n",
    "square = nth_power(2)\n",
    "res1 = square(2)\n",
    "res2 = square(2)\n",
    "res3 = square(2)\n",
    "print(res3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "显然是第二种，是不是？首先直观来看，第二种形式，让你每次调用函数都可以少输入一个参数，表达更为简洁。\n",
    "\n",
    "其次，和上面讲到的嵌套函数优点类似，函数开头需要做一些额外工作，而你又需要多次调用这个函数时，将那些额外工作的代码放在外部函数，就可以减少多次调用导致的不必要的开销，提高程序的运行效率。\n",
    "\n",
    "另外还有一点，我们后面会讲到，闭包常常和装饰器（decorator）一起使用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 总结\n",
    "\n",
    "- Python 中函数的参数可以接受任意的数据类型，使用起来需要注意，必要时请在函数开头加入数据类型的检查；\n",
    "- 和其他语言不同，Python 中函数的参数可以设定默认值；\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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}