docs/python/function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数与函数编程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 函数\n",
    "\n",
    "当调用一个函数时，它的参数是按引用传递给。如果函数的实参一个可变对象（如列表或字典），则函数内对该对象的修改将会影响到函数之外。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, -33, 5]\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4, 5]\n",
    "\n",
    "def foo(x):\n",
    "    global b        # 声明全局变量\n",
    "    b = 10\n",
    "    x[3] = -33      # 修改 x 中的元素\n",
    "\n",
    "foo(a)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果没有指定返回对象或者 `return` 语句被省略，则会返回一个 `None` 对象。如果要返回多个值，可以通过返回一个元组或其它包含对象来完成。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 带默认参数的函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy Birthday! \n",
      "Happy Birthday! Happy Birthday! Happy Birthday! Happy Birthday! \n"
     ]
    }
   ],
   "source": [
    "def repeat_str(s, times=1):\n",
    "    repeated_strs = s * times\n",
    "    return repeated_strs\n",
    "\n",
    "repeated_strings = repeat_str(\"Happy Birthday! \")\n",
    "print(repeated_strings)\n",
    "\n",
    "repeated_strings_2 = repeat_str(\"Happy Birthday! \" , 4)\n",
    "print(repeated_strings_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关键字参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 13 , b: 17 , c: 80\n",
      "a: 12 , b: 40 , c: 24\n",
      "a: 80 , b: 40 , c: 40\n"
     ]
    }
   ],
   "source": [
    "def func(a, b=40, c=80):\n",
    "    print('a:', a, ', b:', b, ', c:', c)\n",
    "\n",
    "func(13, 17)\n",
    "func(12, c=24) # 指定给哪个关键字赋值\n",
    "func(c=40, a=80) # 指定给 a 赋值，可以把它放在后面"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可变长参数的函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `*args` 可变长度元组参数\n",
    "- `**kwargs` 可变长度字典参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fpara: hello1\n",
      "args: ()\n",
      "kwargs: {}\n",
      "\n",
      "fpara: hello2\n",
      "args: (1, 3, 5)\n",
      "kwargs: {}\n",
      "\n",
      "fpara: hello3\n",
      "args: ()\n",
      "kwargs: {'ele': 'world3'}\n",
      "\n",
      "fpara: hello4\n",
      "args: (1, 3)\n",
      "kwargs: {'ele': 'world4'}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def var_paras(fpara, *args, **kwargs):\n",
    "    print(\"fpara: \" + str(fpara))\n",
    "    print(\"args: \" + str(args))\n",
    "    print(\"kwargs: \" + str(kwargs))\n",
    "    print()\n",
    "\n",
    "var_paras(\"hello1\")\n",
    "var_paras(\"hello2\", 1, 3, 5)\n",
    "var_paras(\"hello3\", ele=\"world3\")\n",
    "var_paras(\"hello4\", 1, 3, ele=\"world4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 递归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 对递归函数调用的次数作了限制。函数 `sys.getrecursionlimit()` 返回当前允许的最大递归次数，而函数 `sys.setrecursionlimit()` 可以改变该函数的返回值。\n",
    "\n",
    "默认的最大递归次数为1000，当一个函数递归次数超过最大递归次数时，就会引发 `RuntimeError` 异常."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## lambda 操作符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`lambda` 语句用来创建一个匿名函数（没和名字绑定的函数）：\n",
    "\n",
    "```python\n",
    "lambda args: expression\n",
    "```\n",
    "\n",
    "`args` 是一个用逗号分隔的参数，`expression` 是一个调用这些参数的表达式。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = lambda x, y: x + y\n",
    "print(a(2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`lambda` 定义的代码必须是一个合法的表达式。多重语句和其他非表达式语句（如 `print`、`for`、`while` 等）不能出现在 `lambda` 语句中。`lambda` 表达式也遵循和函数一样的作用域规则。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## map() 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`t = map(func, s)` 函数将序列 `s` 中的每个元素传递给 `func` 函数做参数， 函数的返回值组成了列表 `t`。 即 `t[i] = func(s[i])`。需要注意的是， `func` 函数必须有只有一个参数，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x234d2b83970>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3, 4, 5, 6]\n",
    "def foo(x):\n",
    "    return 3 * x\n",
    "b = map(foo, a)   # b = [3, 6, 9, 12, 15, 18]\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上边的例子中的函数也可以用匿名函数来创建："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x234d2b836a0>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = map(lambda x: 3 * x, a)   # b = [3, 6, 9, 12, 15, 18]\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`map()` 函数也可以用于多个列表，如 `t = map(func, s1, s2, ..., sn)`。 如果是这种形式，`t` 中的每个元素 `t[i] = func(s1[i], s2[i], ..., sn[i])`。`func` 函数的形参个数必须和列表的个数 `n` 相同，结果与 `s1, s2, ..., sn` 中的最长的列表的元素个数相同。在计算过程中，短的列表自动用 `None` 扩充为统一长度的列表。\n",
    "\n",
    "如果函数 `func` 为 `None`，则 `func` 就被当成是恒等函数处理。这样函数就返回一个包含元组的列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x234d2b82fe0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3, 4]\n",
    "b = [100, 101, 102, 103]\n",
    "c = map(None, a, b)  # c = [(1,100), (2,101), (3,102), (4,103)]\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## zip() 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 上边这个例子也可以用 `zip(s1, s2, ..., sn)` 函数来完成。`zip()` 用来将几个序列组合成一个包含元组的序列，序列中的每个元素 `t[i] = (s1[i], s2[i], ..., sn[i])`。 与 `map()` 不同的是， `zip()` 函数将所有较长的序列序列截的和最短序列一样长："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = [1, 2, 3, 4, 5, 6, 7]\n",
    "e = [10, 11, 12]\n",
    "f = zip(d, e)  # f = [(1, 10), (2, 11), (3, 12)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## reduce() 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`reduce(func, s)` 函数从一个序列收集信息，然后只返回一个值（例如求和，最大值等）。它首先以序列的前两个元素调用函数，再将返回值和第三个参数作为参数调用函数，依次执行下去，返回最终的值。 `func` 函数有且只有两个参数。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def sum(x, y):\n",
    "    return x + y\n",
    "b = reduce(sum, a)\n",
    "b  # b = (((1 + 2) + 3) + 4) = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## filter() 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`filter(func, s)` 是个序列过虑器，它使用 `func()` 函数来过滤 `s` 中的元素。使 `func` 返回值为 `false` 的元素被丢弃，其它的存入 `filter` 函数返回的列表中，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = filter(lambda x: x < 4, a)  # c = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果函数 `func` 为 `None`，则 `func` 就被当成是恒等函数处理。这样，函数就返回序列 `s` 中值为 `True` 的元素。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表内涵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "列表内涵可以代替许多调用 `map()` 和 `filter()` 函数的操作。列表内涵的一般形式是：\n",
    "\n",
    "```python\n",
    "[表达式 for item1 in 序列1\n",
    "    for item2 in 序列2\n",
    "        ...\n",
    "            for itemN in 序列N\n",
    "                if 条件表达式]\n",
    "```\n",
    "\n",
    "上边的例子等价于：\n",
    "\n",
    "```python\n",
    "s = []\n",
    "for item1 in sequence1:\n",
    "    for item2 in sequence2:\n",
    "        ...\n",
    "            for itemN in sequenceN:\n",
    "                if condition: s.append(expression)\n",
    "```\n",
    "\n",
    "下面这个代码片段可以帮助你理解列表内涵："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from functools import reduce\n",
    "\n",
    "a = [-3, 5, 2, -10, 7, 8]\n",
    "b = \"abc\"\n",
    "c = [2 * s for s in a]          # c = [-6,10,4,-20,14,16]\n",
    "d = [s for s in a if s >= 0]    # d = [5,2,7,8]\n",
    "e = [                           # e = [(5,'a'),(5,'b'),(5,'c'),\n",
    "    (x, y)                      #      (2,'a'),(2,'b'),(2,'c'),\n",
    "    for x in a                  #      (7,'a'),(7,'b'),(7,'c'),\n",
    "    for y in b                  #      (8,'a'),(8,'b'),(8,'c')]\n",
    "    if x > 0\n",
    "]\n",
    "\n",
    "f = [(1, 2), (3, 4), (5, 6)]    # f = [2.23606, 5.0, 7.81024]\n",
    "g = [math.sqrt(x * x + y * y) for x, y in f]\n",
    "h = reduce(lambda x, y: x + y, [math.sqrt(x * x + y * y) for x, y in f])  # 平方根的和"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "提供给列表内涵的序列不必等长，因为系统内部使用嵌套的一系列 `for` 循环来迭代每个序列中的每个元素，然后由 `if` 从句处理条件表达式，若条件表达式为真，计算表达式的值并放入到列表内涵返回的序列中。 `if` 从句是可选的。\n",
    "\n",
    "当使用列表内涵来构建包含元组的列表时，元组的值必须放在括号里。例如 `[(x, y) for x in a for y in b]` 是一个合法的语句，而 `[x, y for x in a for y in b]` 则不是。\n",
    "\n",
    "最后，你应该注意在一个列表内涵中定义的变量是与列表内涵本身有同样的作用域，在列表内涵计算完成后会继续存在。例如 `[x for x in a]` 会覆盖内涵外先前定义的 `x` ，最终 `x` 的值会是 `a` 中的最后一个元素的值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eval()、exec 和 execfile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`eval(str [, globals [, locals ]])` 函数将字符串 `str` 当成有效 Python 表达式来求值，并返回计算结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(\"3 + 4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "同样地， `exec` 语句将字符串 `str` 当成有效 Python 代码来执行。提供给 `exec` 的代码的名称空间和 `exec` 语句的名称空间相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exec(\"a = 100\")\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "最后，`execfile(filename [, globals [, locals ]])` 函数可以用来执行一个文件，看下面的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey I am in some_main_script in main package.\n",
      "Hey Im a function inside mysubscript\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "\n",
    "sys.path.append(os.getcwd() + \"/modules_and_packages\")\n",
    "\n",
    "execfile(r\"modules_and_packages/myprogram.py\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "默认地，`eval()`、`exec`、`execfile()` 所运行的代码都位于当前的名字空间中。`eval()`、`exec`、`execfile()` 函数也可以接受一个或两个可选字典参数作为代码执行的全局名字空间和局部名字空间。 例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing ../_tmp/foo.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile ../_tmp/function_exec.py\n",
    "result = 3 * x + 4 * y\n",
    "print(result)\n",
    "\n",
    "for b in birds:\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parrot\n",
      "Swallow\n",
      "Albatross\n",
      "61\n",
      "Parrot\n",
      "Swallow\n",
      "Albatross\n"
     ]
    }
   ],
   "source": [
    "globals = {\"x\": 7, \"y\": 10, \"birds\": [\"Parrot\", \"Swallow\", \"Albatross\"]}\n",
    "locals = {}\n",
    "\n",
    "# 将上边的字典作为全局和局部名称空间\n",
    "a = eval(\"3 * x + 4 * y\", globals, locals)\n",
    "exec(\"for b in birds: print(b)\", globals, locals)\n",
    "exec(open(\"../_tmp/function_exec.py\").read(), globals, locals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "如果你省略了一个或者两个名称空间参数，那么当前的全局和局部名称空间就被使用。如果一个函数体内嵌嵌套函数或 `lambda` 匿名函数时，同时又在函数主体中使用 `exec` 或 `execfile()` 函数时， 由于牵到嵌套作用域，会引发一个 `SyntaxError` 异常\n",
    "\n",
    "注意例子中 `exec` 语句的用法和 `eval()`、`execfile()` 是不一样的。 `exec` 是一个语句（就像 `print` 或 `while`），而 `eval()` 和 `execfile()` 则是内建函数。\n",
    "\n",
    "`exec(str)` 这种形式也被接受，但是它没有返回值。\n",
    "\n",
    "当一个字符串被 `eval()`、`exec`、`execfile()` 执行时，解释器会先将它们编译为字节代码，然后再执行。这个过程比较耗时，所以如果需要对某段代码执行很多次时，最好还是对该代码先进行预编译，这样就不需要每次都编译一遍代码，可以有效提高程序的执行效率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## compile()\n",
    "\n",
    "`compile(str, filename, kind)` 函数将一个字符串编译为字节代码, `str` 是将要被编译的字符串， `filename` 是定义该字符串变量的文件，`kind` 参数指定了代码被编译的类型（`'single'` 指单个语句，`'exec'` 指多个语句，`'eval'` 指一个表达式）。`cmpile()` 函数返回一个代码对象，该对象当然也可以被传递给 `eval()` 函数和 `exec` 语句来执行，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "61\n"
     ]
    }
   ],
   "source": [
    "x = 7\n",
    "y = 10\n",
    "\n",
    "str1 = \"for i in range(0, 10): print(i)\"\n",
    "c1 = compile(str1, \"\", \"exec\")  # 编译为字节代码对象\n",
    "exec(c1)  # 执行\n",
    "\n",
    "str2 = \"3 * x + 4 * y\"\n",
    "c2 = compile(str2, \"\", \"eval\")  # 编译为表达式\n",
    "result = eval(c2)  # 执行\n",
    "print(result)"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}