三、函数与递归

 

三、函数与递归                                  返回目录页

1、函数的嵌套调用
2、自定义函数
3、辅助函数
4、匿名函数
5、单行函数
6、递归


引用一个MMA粉丝一段话：
Mathematica支持很多的编程范式（有可能是最多的），其中最为高效的应该就是函数式了，熟悉一点函数式语言的人再来接触Mathematica可能会倍感亲切。通过纯函数（相当于Lambda演算）、高阶函数（Nest、Fold、Map、Apply等等）等各种函数式编程的技巧，你可以轻易写出简洁到爆的程序，而且绝大部分情况下都比过程式版本高效得多。
（ 来源于知乎：https://www.zhihu.com/question/20324243 ）

习惯于过程式编程的人，往往很不习惯这种函数式编程。开始的时候，这种反应是正常的。
我们学习函数式编程，主要是因为可以开阔自己的视野，给自己一个看问题的不同的视角。


-------------------------------------------------------------------------
1、函数的嵌套调用
几个函数的依次作用，被称作嵌套函数调用（nested function call）。
因为函数的返回值，可以作为另一函数参数来用，所以函数可以嵌套调用，一层又一层。
我们学习编程，一般以阅读人家的程序开始。
开始来读懂这个嵌套函数：

Plus[Power[x,3],Power[Plus[1,x],2]]

----------------------------------------
树形结构。
在MMA中，可以将任何一个表达式看作一个树。
函数作为表达式，也是一个树。
树的呈现方式有很多。一般常用的，有两种。

第一种，当然是画出树的图形。用TreeForm函数，很容易画出。
TreeForm[x^3 + (1 + x)^2]
得：一个树形图。

第二种，以一种缩进的方式表达树。
one
    two
        twoL
        twoR
    three
        tL
            L
            R
        tR
根节点是one，根节点下有两个分支：two和three
two节点下，有两个分支：twoL和twoR
three节点下，有两个分支：tL和tR
tL节点下，有两个分支：L和R

那么，上面以第一种方式得到的树形图，可以用第二种方式来表示：
Plus
    Power
        x
        3
    Power
        Plus
            1
            x
        2
标准计算过程采用深度优先方式遍历表达式树。
如果没有学过数据结构，这话听起来有点玄。没有关系，很好理解：
嵌套函数在计算时，从最内层函数开始，一层层向外层函数进行。
那啥叫内层、啥叫外层呢？

----------------------------------------
代码风格。
在MMA中，很多嵌套函数是一行表示的。比如：
Plus[Power[x,3],Power[Plus[1,x],2]]
很多时候，换行会使代码更易读：

Plus[
  Power[
    x,
    3
  ],
  Power[
    Plus[
      1,
      x
    ],
    2
  ]
]
这种以分别两个空格缩进的方式，使代码与树形结构的第二种表达方式很相似了。
如果把[]与逗号去掉，就一模一样了。
所谓内层，指靠近树叶位置的。所谓外层，指靠近树根位置的。
内层先算，得到结果给外层。算到树根，计算结束。
（这不是就是递归运算么？是啊，MMA中大量使用递归运算。）

一个坑爹问题。
上面的缩进代码，Copy到MMA的笔记本中去时，缩进自动完全消失。变成一行了。
一直在找一个合适的MMA代码编辑器，一直没找到。

一个好消息。
当在笔记本中鼠标点击代码的不同部分时，外层函数头与[]会自动着色。
这个对阅读代码很有好处。着色的颜色，可以在菜单 (编辑/偏好设置) 中设定。

MMA自带的编辑器（即笔记本），有自动完成功能，有自动缩进功能，还不算太差，先这么用着吧。

----------------------------------------
分清楚内层外层是第一步。
然后呢，就是按步构造法，就是搞清楚每一步的函数的基本功能。
参数有几个呀、函数的实现功能是啥呀。一步步进行，最后就完全懂了。

Plus[Power[x,3],Power[Plus[1,x],2]]

Plus干啥的？参数有几个？
嗯，如果碰到不太熟悉的函数，鼠标在函数中间任意点点击一下，按“F1”。

这没啥高深的道理，这是一种技能，越用越熟。

----------------------------------------
我们来看一个纸牌程序。先创建，再洗牌。

la = Join[Range[2, 10], {J, Q, K, A}] (*得到十三张牌，没花色的*)
得：{2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A}
这里的la，是值的名称，是个符号，是个绰号，是个别名（nickname）。以后不管它出现在什么地方，都将被这个值本身所取代。
就是说，后面老是用长长一串：{2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A}，麻烦不？
直接用la来代表就可以了。
用完之后，可以把一个值从这个名称上去除掉，两种方法中选取任一种均可：
Clear[la]
la=.

lb = Outer[List, {c, d, h, s}, la]
最后的la，就是{2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A}，没有任何区别。
但代码好读了呀。
从得到的结果来看，这个表的层数太多了。
我们希望得到的，是这样一个表：{ {c,2},{d,A},... }，作为52张牌的数据。
任何一张牌，都可以这样表示：{a,b}。a指花色，b指牌的大小。

层数太多，用Flatten函数来压平好了，指定层数为1：
Flatten[lb, 1]
52张牌的数据就这么愉快地得到了。

我们把la、lb去掉，都用本身，不用绰号，那么就变成了一句：
lc = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1]
当然，输出结果是一样的。
但这个嵌套函数有点长，不易读。
这里我们学到了解读嵌套函数的又一招：用绰号。

Flatten[Transpose[Partition[lc, 26]], 1]
(*Partition是把52张牌一分为二。Tran...是进行转置，即化列为行。最后压平。洗牌完毕*)

如果我们不用绰号，整个洗牌程序就是这么长长的一串：
Flatten[Transpose[Partition[Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1], 26]], 1]

你可能会觉得，这个洗牌程序洗出来的牌，太有规律了，不够乱。不急，这副牌会跟随我们很长时间，以后还会不断玩牌。

从这一节，我们看到，函数式编程的第一大特点：啥都是函数，函数套函数，层层叠叠。
不过，我们已经掌握了几种解读嵌套函数的技巧。


-------------------------------------------------------------------------
2、自定义函数
MMA中的内置函数虽然很多，但用户的需求是无穷多的，很多时候必须自定义（user-defined）函数。
比如发牌程序，就不是内置函数。
自定义函数的一般格式：

name[arg1,arg2,...,argn] := body

依次为函数名（function name），函数参数（gargument），函数主体（body）
特别的一点是，函数参数必须以下划线（blank）结尾，比如：x_

因为内置函数以大写字母开头，所以一般我们取自定义函数名的时候，就不以大写字母开头了。

square[x_] := x^2
square[3]

函数经过自定义，就可以像内置函数一样使用了。

----------------------------------------
准备发牌。

cardDeck = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]]
第一行不用解释了。第二行，自定义了一个函数，函数功能是从一个表中，随机删除一个元素。
RandomInteger[{1, Length[lis]}]
产生一个1到表长度中的一个随机整数。

cardDeck = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]];
removeRand[cardDeck]
调用函数后，就有了一个表的输出。能够发现少了哪张牌么？

真的去数了么？哈哈，恭喜你，上当了。
一般玩程序的，能用程序解决的，不会去干手工。

Complement[cardDeck, %]
加一句，少的那张牌就出来了。
奇怪啊，已经删除了，怎么出来的？
Complement有取补集的功能。把cardDeck看成全集，把%中部分的51张牌，看成是一个子集，那么补集就是删除的那张牌了。

发n张牌，就这样写：
deal[n_] := Complement[cardDeck, Nest[removeRand, cardDeck, n]]
其中，Nest[removeRand, cardDeck, n] 的意思是，不断在剩余的牌中随机删除一张，直到删除了n张。

发5张牌全部程序就是：
cardDeck = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]];
deal[n_] := Complement[cardDeck, Nest[removeRand, cardDeck, n]];
deal[5]

Map[deal, Table[5, {4}]] // MatrixForm
这样就给四个人发了五张牌

Map[deal, Table[2, {6}]]
deal[5]
那就是六个人在玩德州梭哈，每个人发两张牌。然后，在中间发五张牌。

发现木有？我们在这章到现在使用的内置函数，全部都是在前一章表操作函数中学过的。


-------------------------------------------------------------------------
3、辅助函数
辅助（auxiliary）函数，可以理解为自定义函数嵌套，即自定义函数的函数体内，还有自定义函数。
分两种格式：复合函数（compound function）与Module。

复合函数的基本格式：
name[arg1,arg2...,argn] := (expr1; expr2; ... ; exprm)
函数体在()中，只有最后一个表达式exprm有输出。

把前面的发牌程序改一下，就成这样：

Clear[deal, cardDeck, removeRnad];
deal[n_] := (
  cardDeck = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
  removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]];
  Complement[cardDeck, Nest[removeRand, cardDeck, n]]
)
deal[5]

程序可读性增加了。但是，cardDeck之类的名称，还是全局可见的，所以这种格式不常用。
而以下的Module格式，把cardDeck之类的名称，作为局部的，全局不可见，所以就比较常用了。

name[arg1_,...] := Module[{name1,name2=value,...}, expr]
Module中的第一个参数，是个表。表中就是我们想要把它们的名称局部化的表达式。

Clear[deal, cardDeck, removeRnad];
deal[n_] :=
 Module[{removeRand, cardDeck},
  cardDeck =
   Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
  removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]];
  Complement[cardDeck, Nest[removeRand, cardDeck, n]]]
deal[5]

把名称，通过Module格式局部化，经常是个好主意。
局部化名称的颜色，设置得显眼一点，也是个好主意。在菜单  编辑/偏好设置  中设置。


-------------------------------------------------------------------------
4、匿名函数
匿名函数（anonymous function）的名称可多了，无名函数，纯函数（连名字也没了，确实比较纯：））
匿名函数的特点是，它没有函数名。
一般我们说调用函数，先写上函数名。匿名函数没有函数名，所以是当场使用，一次性。
定义匿名函数，有两种方式。

第一种是使用内置函数Function：
Function[{x,y,...}, body]

Function[x,x^2] [3]
得9
创建函数后，马上用掉，一次性。对于以前反复使用大茶缸的，现在使用一次性茶杯，不习惯是正常的。
用多了就习惯性了。如果想不一次性，给匿名函数起个名，那也是可以的：
square = Function[x, x^2];
square[3]
得9

第二种是使用语法糖：
(#1,#2...)&
反正看到这种模样：(...)& ，就要想到，这是个无名函数。记住：()&，这三个字符，是个整体。
当参数只有一个时，可以使用#。当然了，使用#1也是可以的。
(#^2)&[3]
(#1^2)&[3]
这两句是等效的。
以这种定义方式，给无名函数起个名，也一样是可以的：
square = (#^2)&;
square[3]
一些简单的自定义函数，通过这种方式定义，还是简洁可行的。不过一般不这样做。
无名函数的主要功能是一次性。

无名函数作为函数，当然也可以嵌套使用。
(Map[(#^2)&, #])& [{1,2,3}]
表达式的运算过程，是从内层到外层。但解读程序时，很多时候从外层到内层，能抓住整体性。
(Map[(#^2)&, #])& 这是一个函数。
[{1,2,3}] 这是函数参数。

(Map[(#^2)&, #])& 这个函数，把()&部分剥离，得：
Map[(#^2)&, #]
逐渐清晰，这是个Map函数，功能是把某函数（(#^2)&）分别作用于某表（#）。
注意啊，以上两个#，所代表的含义完全不同。
第一个#，是函数(#^2)&的参数。第二个#，是函数Map的参数。

使用第一种方式来写，会不会清楚点呢？
Function[y,Map[Function[x,x^2],y]] [{1,2,3}]

写一起，比比看：
(Map[(#^2)&, #])& [{1,2,3}]
Function[y,Map[Function[x,x^2],y]] [{1,2,3}]

----------------------------------------
用无名函数来发牌。

以前的自定义函数：
Clear[deal, cardDeck, removeRnad];
deal[n_] :=
 Module[{removeRand, cardDeck},
  cardDeck =
   Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
  removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]];
  Complement[cardDeck, Nest[removeRand, cardDeck, n]]]
deal[5]

改写成匿名函数：(*无非是去掉个函数名：removeRand*)
Clear[deal, cardDeck, removeRnad];
deal[n_] :=
 Module[{cardDeck},
  cardDeck =
   Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
   Complement[cardDeck, Nest[(Delete[#, RandomInteger[{1, Length[#]}]])&, cardDeck, n]]]
deal[5]
个人感觉，这种改写，意义不大。

从一个表中，随机不重复地选择几个元素出来，这程序比较有实用性：
chooseWithoutReplacement[lis_,n_] :=
  Complement[lis, Nest[(Delete[#, RandomInteger[{1, Length[#]}]])&, lis, n]];
chooseWithoutReplacement[Range[10],5]

上面的程序，已经没有必要用Module了，因为自定义的名称木有了，只有一些无名函数、内置函数等等。
具有这种形式的函数，称为单行函数（one-liner）。

这一节，以做出一个完全二叉树作为结尾。
Nest[{#, #} &, x, 3] // TreeForm


-------------------------------------------------------------------------
5、单行函数
单行函数，可以理解为无名函数的一个运用。
一个自定义函数一个语句解决。

关于约瑟夫问题，是指n个人围成圈，从第一个开始绕圈数1到m（这里m为2，即间隔数）。
不断数，每次数到m的人出局，一直到剩下最后一个人。

这里用表及表处理，作了模拟（让整个圈子的人转动，这点有点新意）。还给出了过程：
survivor[lis_] :=
 Nest[(Rest[RotateLeft[#]]) &, lis, Length[lis] - 1]
(*RotateLeft是向左转圈。Rest是把表中第一个元素去掉。Nest是不断重复，结果是参数。最后一个参数是重复次数*)
survivor[Range[10]] (*调用函数*)
TracePrint[survivor[Range[10]], RotateLeft]
(*第二个参数，是TracePrint的参数。只跟踪RotataLeft相关的数据。。*)


-------------------------------------------------------------------------
6、递归
递归是这样一种函数：在自定义函数时，函数体内用到函数名本身。
递归在MMA内部大量使用，因为表达式的内部存放形式是树形，而递归是遍历树形的最通常的方式。
树的层数不多时，递归的效率是高的。反之递归的效率极低。

我们从斐波那契数（Fibonacci number）开始。
Fib是指这样一种数列：从0、1开始，后面的所有项，都是前两项之和。

f[n_] := f[n - 2] + f[n - 1];
f[6]

运行这个程序，可以看到警告：超过1024的递归深度。
因为没有递归基。
在递归的过程中，函数不断调用自己，总要碰到一个不需要递归便可计算出来的值，作为返回。否则就一直调用自己，停止不下来了。这个可确定计算出来的值，称为递归基。在Fib中，递归基是开始的两个数，0和1。

f[0]=0;
f[1]=1;
f[n_] := f[n - 2] + f[n - 1];
f[6]
确定递归基后，程序能正常运行了。
这个程序的内部结构是个二叉树，存在大量的重复计算，效率是极低的。

可以考虑用一种叫动态程序设计的方法，把中间结果保存下来。
f[0] := 0
f[1] := 1
f[n_] := f[n] = f[n - 2] + f[n - 1]
f[2000]

(*
其实啊，这只是举例。真正要提高算Fib的效率，直接迭代效率最高。
fib[n_] :=
 Module[{a = 0, b = 1, c = 1, i = 2},
  While[i < n, a = b; b = c; c = a + b; i++];
  c]
fib[5]
把5改成50000试试？一样很快。
*)

----------------------------------------
很多表处理函数，也可以用递归实现。

比如：
length[lis_] := length[Rest[lis]] + 1
length[{}] := 0
length[{1, 2, 3}]
这里写成length，以示与内置函数Length的区别。

----------------------------------------
我们把发牌程序，写成递归形式。

原来的：
deal[n_] :=
 Module[{removeRand, cardDeck},
  cardDeck = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
  removeRand[lis_] := Delete[lis, RandomInteger[{1, Length[lis]}]];
  Complement[cardDeck, Nest[removeRand, cardDeck, n]]]
deal[5]

递归的：
cardDeck = Flatten[Outer[List, {c, d, h, s}, Join[Range[2, 10], {J, Q, K, A}]], 1];
deal[0] := {}
deal[n_] := Module[{dealt = deal[n - 1]},
  Append[dealt, Complement[cardDeck, dealt] [[RandomInteger[{1, 53 - n}]]]]]
deal[5]

递归基是空表，因为啥牌也没有发。
很多时候啊，我们不必知道递归细节。但要知道思路。
一般的设计递归程序的思路是，假设已经完成了n-1步，那么第n步怎么办？

这里，我们假设已经发了n-1张牌。
dealt是个局部名称，记录了所发的n-1张牌的表。
在剩下的牌中，随机取一张，添加到n-1张牌中去，那么n张牌就发好了。
Complement[cardDeck, dealt]  ：剩下的牌
[[RandomInteger[{1, 53 - n}]]]  ：随机取一张。
牌共有52张，已经发掉了n-1张，所以剩下张数为：52-(n-1)=53-n。


----------------------------------------
最后，我们再来看一个递归程序，来结束本节、本章。

二叉树的基本单元，根节点记为“one”，左节点记为“oneL”，右节点记为“oneR”
那么我们用表来表示是：
{"one",{"oneL","oneR"}}
如果左右节点均有分支，那么表就不断嵌套。

我们来编制一个递归程序，来遍历这个二叉树表，而输出以缩进格式表示树结构，比如：
one
    two
        twoL
        twoR
    three
        tL
            L
            R
        tR

程序为：
----------------------------------------
printTree[t_] := printTree[t, 0] (*输出空，相当于没输出*)
printTree[{lab_}, k_] := printIndented[lab, 4 k] (*输出几个空格、内容*)
printIndented[x_, spaces_] :=
 Print[Apply[StringJoin, Table[" ", {spaces}]], x]

printTree[{lab_, lc_, rc_}, k_] :=
 (
  printIndented[lab, 4 k]; (*输出几个空格、内容*)
  Map[(printTree[#, k + 1]) &, {lc, rc}];  (*递归，遍历子树。这个程序只能处理二叉树*)
  )

printTree[{"one", {"two", {"twoL"}, {"twoR"}}, {"three", {"tL", {"L"}, {"R"}}, {"tR"}}}]
----------------------------------------

printTree[t_] := printTree[t, 0] (*输出空，相当于没输出*)
printTree[{lab_}, k_] := printIndented[lab, 4 k] (*输出几个空格、内容*)
printIndented[x_, spaces_] := 
 Print[Apply[StringJoin, Table[" ", {spaces}]], x] 

printTree[{lab_, lc_, rc_}, k_] :=
 (
  printIndented[lab, 4 k]; (*输出几个空格、内容*)
  Map[(printTree[#, k + 1]) &, {lc, rc}];  (*递归，遍历子树。这个程序只能处理二叉树*)
  ) 

printTree[{"one", {"two", {"twoL"}, {"twoR"}}, {"three", {"tL", {"L"}, {"R"}}, {"tR"}}}]

View Code

总的思路是，把二叉树图形，转化为表，再用自定义函数，把表转化为缩进格式的文本。

TreeForm[x^3 + (1 + x)^2]
这个程序产生的二叉树图，转化为表：
lis={"Plus", {"Power", {"x"}, {"3"}}, {"Power", {"Plus", {"1"}, {"x"}}, {"2"}}}
printTree[lis]
调用函数，得：

Plus
    Power
        x
        3
    Power
        Plus
            1
            x
        2

从而我们看到了二叉树的不同表达形式。

 

 

++++++++++++++++++++++++++++++++++++++++++

扩展阅读：《计算机程序的构造和解释（SICP）》，传说中的MIT教程，函数式编程必读书。
豆瓣上的评价（链接）
这本书的中文版翻译得很好（作者叫裘宗燕，听起来是个女士，实际上是个大男人:)）。这本书中，用的是Scheme语言，不是伪代码。下载一个PLT Scheme，就可以玩Lisp方言Scheme了。（这本书的中文版的pdf，及玩PLT Scheme的安装程序，均在目录页的百度云中提供下载。）
知乎上的讨论（链接）






                    Top

 

转载于:https://www.cnblogs.com/xin-le/p/5992397.html