|
4 | 4 | "cell_type": "markdown", |
5 | 5 | "metadata": {}, |
6 | 6 | "source": [ |
7 | | - "# 函数设计概念 \n", |
| 7 | + "# 1. 函数设计概念 \n", |
8 | 8 | "\n", |
9 | 9 | "**通用指导方针**:\n", |
10 | 10 | "- 耦合性:对于输入使用参数并且对于输出使用 return 语句。\n", |
|
19 | 19 | "cell_type": "markdown", |
20 | 20 | "metadata": {}, |
21 | 21 | "source": [ |
22 | | - "# 递归函数 \n", |
| 22 | + "# 2. 递归函数 \n", |
23 | 23 | "直接或间接地调用自身以进行循环的函数。它允许程序遍历拥有任意的、不可预知的形状的结构。 \n", |
24 | 24 | "\n", |
25 | 25 | "递归在大多数情况下不必使用,很可能递归在内存空间和执行时间方面效率较低。 \n", |
26 | 26 | "\n", |
27 | | - "## 用递归求和 " |
| 27 | + "## 2.1 用递归求和 " |
28 | 28 | ] |
29 | 29 | }, |
30 | 30 | { |
|
57 | 57 | "cell_type": "markdown", |
58 | 58 | "metadata": {}, |
59 | 59 | "source": [ |
60 | | - "## 处理任意结构 \n", |
| 60 | + "## 2.2 处理任意结构 \n", |
61 | 61 | "递归可以要求遍历任意形状的结构,考虑计算一个嵌套的子列表结构中所有数字的总和:[1, [2, [3, 4], 5], 6, [7, 8]]" |
62 | 62 | ] |
63 | 63 | }, |
|
92 | 92 | "cell_type": "markdown", |
93 | 93 | "metadata": {}, |
94 | 94 | "source": [ |
95 | | - "# 函数对象:属性和注解 \n", |
96 | | - "## 间接函数调用 \n", |
| 95 | + "# 3. 函数对象:属性和注解 \n", |
| 96 | + "## 3.1 间接函数调用 \n", |
97 | 97 | "函数对象可以赋值给其他的名字、传递给其他函数、嵌入到数据结构、从一个函数返回给另一个函数等等。 \n", |
98 | 98 | "\n", |
99 | 99 | "函数对象还恰好支持一个特殊操作:它们可以由一个函数表达式后面的括号中的列表参数调用。 \n", |
|
197 | 197 | "cell_type": "markdown", |
198 | 198 | "metadata": {}, |
199 | 199 | "source": [ |
200 | | - "## 函数内省 \n", |
| 200 | + "## 3.2 函数内省 \n", |
201 | 201 | "由于函数是对象,我们可以用常规的对象工具来处理函数,也可以通用地检查它们的属性:" |
202 | 202 | ] |
203 | 203 | }, |
|
407 | 407 | "cell_type": "markdown", |
408 | 408 | "metadata": {}, |
409 | 409 | "source": [ |
410 | | - "## 函数属性 \n", |
| 410 | + "## 3.3 函数属性 \n", |
411 | 411 | "函数对象不仅限于前面列出的系统定义的属性,也可能向函数附加任意的用户定义的属性:" |
412 | 412 | ] |
413 | 413 | }, |
|
544 | 544 | "cell_type": "markdown", |
545 | 545 | "metadata": {}, |
546 | 546 | "source": [ |
547 | | - "## Python 3.X 中的函数注解 \n", |
| 547 | + "## 3.4 Python 3.X 中的函数注解 \n", |
548 | 548 | "在 Python 3.X 中,也可以给函数对象附加注解信息——与函数的参数和结果相关的任意的用户定义的数据。 \n", |
549 | 549 | "\n", |
550 | 550 | "注解本身不做任何事情,完全是可选的,并且出现的时候只是直接附加到函数对象的 `__annotations__` 属性以供其他用户使用。 \n", |
|
613 | 613 | }, |
614 | 614 | { |
615 | 615 | "cell_type": "code", |
616 | | - "execution_count": 21, |
617 | | - "metadata": { |
618 | | - "collapsed": true |
619 | | - }, |
620 | | - "outputs": [], |
| 616 | + "execution_count": 1, |
| 617 | + "metadata": {}, |
| 618 | + "outputs": [ |
| 619 | + { |
| 620 | + "data": { |
| 621 | + "text/plain": [ |
| 622 | + "6" |
| 623 | + ] |
| 624 | + }, |
| 625 | + "execution_count": 1, |
| 626 | + "metadata": {}, |
| 627 | + "output_type": "execute_result" |
| 628 | + } |
| 629 | + ], |
621 | 630 | "source": [ |
622 | 631 | "def func(a: 'spam' = 4, b: (1, 10) = 5, c: float = 6) -> int:\n", |
623 | | - " return a + b + c" |
| 632 | + " return a + b + c\n", |
| 633 | + "\n", |
| 634 | + "func(1, 2, 3)" |
624 | 635 | ] |
625 | 636 | }, |
626 | 637 | { |
627 | 638 | "cell_type": "markdown", |
628 | 639 | "metadata": {}, |
629 | 640 | "source": [ |
630 | | - "## Python 3.5 中引入的 Type Hints \n", |
| 641 | + "## 3.5 Python 3.5 中引入的 Type Hints \n", |
631 | 642 | "函数注解的语义未定义,经验表明,大多数函数注解用于为函数参数和返回值提供类型提示。很明显,如果标准库包含类型注解的基本定义和工具,那么对 Python 用户来说将是有益的。因此 Python 3.5 中引入了 Type Hints,可以在注解中声明类型:" |
632 | 643 | ] |
633 | 644 | }, |
|
652 | 663 | "cell_type": "markdown", |
653 | 664 | "metadata": {}, |
654 | 665 | "source": [ |
655 | | - "# 匿名函数:lambda \n", |
| 666 | + "# 4. 匿名函数:lambda \n", |
656 | 667 | "lambda 表达式创建了一个之后能够调用的函数,但是它返回了一个函数而不是将这个函数赋值给一个变量名。出于对可读性的要求,通常来说,最好避免使用嵌套的 lambda。 \n", |
657 | 668 | "\n", |
658 | | - "## lambda 表达式 \n", |
| 669 | + "## 4.1 lambda 表达式 \n", |
659 | 670 | "lambda 的一般形式是关键字 lambda,之后是一个或多个参数,紧跟的是一个冒号,之后是一个表达式:" |
660 | 671 | ] |
661 | 672 | }, |
|
760 | 771 | "cell_type": "markdown", |
761 | 772 | "metadata": {}, |
762 | 773 | "source": [ |
763 | | - "## 为什么使用 lambda \n", |
| 774 | + "## 4.2 为什么使用 lambda \n", |
764 | 775 | "lambda 起到了一种函数速写的作用,允许在使用的代码内嵌入一个函数的定义。 \n", |
765 | 776 | "\n", |
766 | 777 | "lambda 通常用来编写跳转表(jump table),也就是行为的列表或字典,能够按照需要执行相应的动作:" |
|
835 | 846 | "cell_type": "markdown", |
836 | 847 | "metadata": {}, |
837 | 848 | "source": [ |
838 | | - "# 函数式编程工具 \n", |
839 | | - "## 在可迭代对象中映射函数:map \n", |
| 849 | + "# 5. 函数式编程工具 \n", |
| 850 | + "## 5.1 在可迭代对象中映射函数:map \n", |
840 | 851 | "程序对列表和其他序列常常要做的一件事就是对每一个元素进行一个操作并把其结果集合起来。 \n", |
841 | 852 | "\n", |
842 | 853 | "map 函数会对一个序列对象中的每一个元素应用被传入的函数,并且返回一个包含了所有函数调用结果的一个列表:" |
|
958 | 969 | "cell_type": "markdown", |
959 | 970 | "metadata": {}, |
960 | 971 | "source": [ |
961 | | - "## 在可迭代对象中选择元素:filter \n", |
| 972 | + "## 5.2 在可迭代对象中选择元素:filter \n", |
962 | 973 | "函数式编程就是对序列应用一些函数的工具,filter 基于某一测试函数过滤出一些元素,序列中的元素若其返回值为真的话,将会被键入到结果的列表中。例如,从一个序列中挑选出大于 0 的元素:" |
963 | 974 | ] |
964 | 975 | }, |
|
1033 | 1044 | "cell_type": "markdown", |
1034 | 1045 | "metadata": {}, |
1035 | 1046 | "source": [ |
1036 | | - "## 在可迭代对象中组合元素:reduce \n", |
| 1047 | + "## 5.3 在可迭代对象中组合元素:reduce \n", |
1037 | 1048 | "reduce 在 Python 3.X 中位于 functools 模块中,它接受一个可迭代对象来处理,但是本身不是一个可迭代对象,它返回一个单个的结果。" |
1038 | 1049 | ] |
1039 | 1050 | }, |
|
1105 | 1116 | "name": "python", |
1106 | 1117 | "nbconvert_exporter": "python", |
1107 | 1118 | "pygments_lexer": "ipython3", |
1108 | | - "version": "3.6.5" |
| 1119 | + "version": "3.6.8" |
1109 | 1120 | }, |
1110 | 1121 | "toc": { |
1111 | 1122 | "nav_menu": {}, |
|
0 commit comments