一、lambda匿名函数详解
lambda函数是快速定义单行的最小函数，是从Lisp借用的，可以在需要函数的地方使用。1 .以下示例比较了传统的函数定义def和lambda的定义方法。
德夫(x，y ) :
.返回x * y
.
f (2，3 ) ) )。
6
g=lambda x，y: x * y
g (2，3 ) )。
根据6所述，两个函数得到相同的结果，但对于实现简单功能的函数，可以使用lambda函数进行更紧凑、更灵活的定义。 也可以将函数直接分配给一个变量，然后用变量名称表示函数名称。 其实，lambda函数很多时候不需要代入变量。
lambda函数的使用有几个注意事项
lambda函数接受任意数量的参数，包括可选参数，并返回一个表达式的值。 lambda函数不能包含命令。 此外，不能包含多个表达式。 lambda语句用于创建函数对象。 基本上，lambda需要参数，后面只有一个表达式作为函数体，表达式的值由这个新创建的函数返回。 请注意，print语句也不能以lambda格式使用，只能使用表达式。 3. def和lambda的区别
lambda在python上使用lambda创建匿名函数，但使用def创建的方法有名称。 lambda会创建函数对象，但不会将此函数对象分配给标识符，而def会将函数对象分配给变量。 lambda是表达式，def是语句。 因为def是一个语句，所以并不是不能嵌套表达式。 lambda表达式只能在“:”之后有一个表达式。 也就是说，在def中，可以在return中返回的东西可以放在lambda后面，不能在return中返回的东西也不能在python lambda后面定义。 因此，像if、for和print这样的语句不能用于lambda。 lambda一般只用于定义简单的函数。 4 .示例
类人猿：
age=0
gender='male '。
def _ init _ (自、自、生) :
自我介绍=自我介绍
self . gender=gender
EF tostring (自助) :
返回代理： ' str (自助.代理)/t生成器： '自助.生成器
list=[人造(21，'人造) 20，'人造)，人造) 34，'人造)，
朋友(19，“失败”)
打印足球甲级联赛： '
列表：之外
使用打印p.tostring (
list.sort(lambdaP1，p 2:厘米) p2 . age，p2 . age ) )
打印'/Nafterascendingsort : '
列表：之外
使用打印p.tostring (
list.sort(lambdaP1，P2:-CMP ) p2 . age，p2 . age ) )
打印'/Nafterdescendingsort : '
列表：之外
print p . toString ()
二、递归函数
1.定义在函数内部，可以调用其他函数。 如果某个函数在内部调用自己，则该函数是递归函数。
2 .递归特性
请记住，所有递归函数的结束条件在相邻的两次重复之间存在密切的联系。 上一次必须做下一次的准备。 上一次的输出通常是下一次的输入。 递归没有效率。 递归层次过多会导致堆栈溢出。 (在计算机中，函数调用是通过一种叫做堆栈的数据结构实现的，每次进入一个函数调用时，都会在堆栈中添加一个堆栈帧，每次函数返回时，堆栈都会减少一个堆栈帧。 因为栈的大小不是无限的，所以递归调用的次数过多会导致栈溢出()递归的层数在python中是有限的997/998层，可以使用sys模块来更改递归的层数(sys.ss8 ) 3 .实例详细情况
计算阶乘n！=1 x 2 x 3 x . x n
fact(n )可以表示为nxfact ) n-1 )，只有在n=1时才需要特别的处理。
deffact(n ) :
if n==1:
返回1
计算returnn*fact(5(n-1 ) fact )5)时，从函数的定义中可以看到如下的计算过程。
===fact(5)。
===5*脸部(4)
===5* (4*传真)3) )
===5*(4* )3*fact )2) )
===5*(4* )3* )2*面貌(1) )
==
==> 5 * (4 * (3 * (2 * 1))) ===> 5 * (4 * (3 * 2)) ===> 5 * (4 * 6) ===> 5 * 24 ===> 120递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：
>>> fact(1000) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in fact ... File "<stdin>", line 4, in fact RuntimeError: maximum recursion depth exceeded解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：
def fact(n): return fact_iter(1, 1, n) def fact_iter(product, count, max): if count > max: return product return fact_iter(product * count, count + 1, max)可以看到，return fact_iter(product * count, count + 1, max)仅返回递归函数本身，product * count和count + 1在函数调用前就会被计算，不影响函数调用。
fact(5)对应的fact_iter(1, 1, 5)的调用如下：
===> fact_iter(1, 1, 5) ===> fact_iter(1, 2, 5) ===> fact_iter(2, 3, 5) ===> fact_iter(6, 4, 5) ===> fact_iter(24, 5, 5) ===> fact_iter(120, 6, 5) ===> 120尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。
有一个针对尾递归优化的decorator，可以参考源码：
http://code.activestate.com/recipes/474088-tail-call-optimization-decorator/
#!/usr/平常的芹菜/env python2.4 # This program shows off a python decorator( # which implements tail call optimization. It # does this by throwing an exception if it is # it's own grandparent, and catching such # exceptions to recall the stack. import sys class TailRecurseException: def __init__(self, args, kwargs): self.args = args self.kwargs = kwargs def tail_call_optimized(g): """ This function decorates a function with tail call optimization. It does this by throwing an exception if it is it's own grandparent, and catching such exceptions to fake the tail call optimization. This function fails if the decorated function recurses in a non-tail context. """ def func(*args, **kwargs): f = sys._getframe() if f.f_back and f.f_back.f_back and f.f_back.f_back.f_code == f.f_code: raise TailRecurseException(args, kwargs) else: while 1: try: return g(*args, **kwargs) except TailRecurseException, e: args = e.args kwargs = e.kwargs func.__doc__ = g.__doc__ return func @tail_call_optimized def factorial(n, acc=1): "calculate a factorial" if n == 0: return acc return factorial(n-1, n*acc) print factorial(10000) # prints a big, big number, # but doesn't hit the recursion limit. @tail_call_optimized def fib(i, current = 0, next = 1): if i == 0: return current else: return fib(i - 1, next, current + next) print fib(10000) # also prints a big number, # but doesn't hit the recursion limit.现在，只需要使用这个@tail_call_optimized，就可以顺利计算出fact(1000)：
>>> fact(1000) 4023872600770937735437024339230039857193748642107146325437999104299385123986290205920442084869694048004799886101971960586316668729948085589013238296699445909974245040870737599188236277271887325197795059509952761208749754624970436014182780946464962910563938874378864873371191810458257836478499770124766328898359557354325131853239584630755574091142624174743493475534286465766116677973966688202912073791438537195882498081268678383745597317461360853795345242215865932019280908782973084313928444032812315586110369768013573042161687476096758713483120254785893207671691324484262361314125087802080002616831510273418279777047846358681701643650241536913982812648102130927612448963599287051149649754199093422215668325720808213331861168115536158365469840467089756029009505376164758477284218896796462449451607653534081989013854424879849599533191017233555566021394503997362807501378376153071277619268490343526252000158885351473316117021039681759215109077880193931781141945452572238655414610628921879602238389714760885062768629671466746975629112340824392081601537808898939645182632436716167621791689097799119037540312746222899880051954444142820121873617459926429565817466283029555702990243241531816172104658320367869061172601587835207515162842255402651704833042261439742869330616908979684825901254583271682264580665267699586526822728070757813918581788896522081643483448259932660433676601769996128318607883861502794659551311565520360939881806121385586003014356945272242063446317974605946825731037900840244324384656572450144028218852524709351906209290231364932734975655139587205596542287497740114133469627154228458623773875382304838656889764619273838149001407673104466402598994902222217659043399018860185665264850617997023561938970178600408118897299183110211712298459016419210688843871218556461249607987229085192968193723886426148396573822911231250241866493531439701374285319266498753372189406942814341185201580141233448280150513996942901534830776445690990731524332782882698646027898643211390835062170950025973898635542771967428222487575867657523442202075736305694988250879689281627538488633969099598262809561214509948717012445164612603790293091208890869420285106401821543994571568059418727489980942547421735824010636774045957417851608292301353580818400969963725242305608559037006242712434169090041536901059339838357779394109700277534720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004. 总结
使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。