【Python3之匿名函数及递归】

一、匿名函数及内置函数补充

1.语法

Python使用lambda关键字创造匿名函数。所谓匿名,意即不再使用def语句这样标准的形式定义一个函数。

语法:

lambda [arg1[, arg2, ... argN]]: expression

例:

普通函数

def func(x,y):
return x+y print(func)
print(func(1,2))

输出

<function func at 0x102b31f28>
3

等价的匿名函数

#匿名函数
f=lambda x,y:x+y
print(f) print(f(1,2))

输出

<function <lambda> at 0x107a55f28>
3

2.匿名函数配合内置函数的用法

  • max,min,zip,sorted的用法
  • max(arg1, arg2, *args[, key]) #key=keyfunc
salaries={
'e':3000,
'a':100000000,
'w':10000,
'y':2000
} print(max(salaries)) #默认比较key值大小
res=zip(salaries.values(),salaries.keys()) #以values比较
print(max(res))
  • 配合匿名函数实现上面功能
salaries={
'e':3000,
'a':100000000,
'w':10000,
'y':2000
} def func(k):
return salaries[k] print(max(salaries,key=func)) #传递函数
print(max(salaries,key=lambda k:salaries[k])) #配合匿名函数,比较values
print(min(salaries,key=lambda k:salaries[k]))
# print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默认的排序结果是从小到到

输出

a
a
y

补充:

  • map(functioniterable...)
  • 对可迭代函数'iterable'中的每一个元素应用‘function’方法,将结果作为list返回。

例:

l=['a','w','y']
res=map(lambda x:x+'_12',l)
print(res)
print(list(res)) nums=(2,4,9,10)
res1=map(lambda x:x**2,nums)
print(list(res1))

输出

<map object at 0x108e0bef0>
['a_12', 'w_12', 'y_12']
[4, 16, 81, 100]
  • reduce(function, sequence[, initial]) -> value
  • 对sequence中的item顺序迭代调用function,函数必须要有2个参数。要是有第3个参数,则表示初始值,可以继续调用初始值,返回一个值。
l=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,l,10))  #10+1+2+3+4+5

输出

25

  • filter(function or None, sequence) -> list, tuple, or string
  • 对sequence中的item依次执行function(item),将执行结果为True(!=0)的item组成一个List/String/Tuple(取决于sequence的类型)返回,False则退出(0),进行过滤。
l=['a_SB','w_SB','y','egon']

res=filter(lambda x:x.endswith('SB'),l)
print(res)
print(list(res))

输出

<filter object at 0x10bc43ef0>
['a_SB', 'w_SB']

二、递归调用

1.定义

递归就是在过程或函数里调用自身,在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口。

递归的两个阶段:

递归和回溯

2.递归思想

例:

阶乘函数的定义是:
N! = factorial(N) = 1 * 2 * 3 * ... * N

那么可以用这种方法来看阶乘函数:
factorial(N) = N!
             = N * (N - 1)!
             = N * (N - 1) * (N - 2)!
             = N * (N - 1) * (N - 2) * ... * 3 * 2 * 1
             = N * factorial(N - 1)

于是我们有了阶乘函数的递归版本:

def factorial(n):
if n == 0 or n == 1: return 1
else: return (n * factorial(n - 1)) print(factorial(6))

可以很轻易的得到,6!的结果是720。

每一个递归程序都遵循相同的基本步骤: 
1.初始化算法。递归程序通常需要一个开始时使用的种子值(seed value)。要完成此任务,可以向函数传递参数,或者提供一个入口函数,这个函数是非递归的,但可以为递归计算设置种子值。 
2.检查要处理的当前值是否已经与基线条件相匹配(base case)。如果匹配,则进行处理并返回值。 
3.使用更小的或更简单的子问题(或多个子问题)来重新定义答案。 
4.对子问题运行算法。 
5.将结果合并入答案的表达式。 
6.返回结果。

3.用途

递归算法一般用于解决三类问题:
(1)数据的定义是按递归定义的。(比如Fibonacci函数)
(2)问题解法按递归算法实现。(回溯)
(3)数据的结构形式是按递归定义的。(比如树的遍历,图的搜索)   

递归的缺点:递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

4.二分法

l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]

def search(find_num,seq):
if len(seq) == 0:
print('not exists')
return
mid_index=len(seq)//2
mid_num=seq[mid_index]
print(seq,mid_num)
if find_num > mid_num:
#in the right
seq=seq[mid_index+1:]
search(find_num,seq)
elif find_num < mid_num:
#in the left
seq=seq[:mid_index]
search(find_num,seq)
else:
print('find it') search(77,l)
search(72,l)
search(-100000,l)

输出

[1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
[77, 85, 101, 201, 202, 999, 11111] 201
[77, 85, 101] 85
[77] 77
find it
[1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
[1, 2, 10, 33, 53, 71, 73] 33
[53, 71, 73] 71
[73] 73
not exists
[1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
[1, 2, 10, 33, 53, 71, 73] 33
[1, 2, 10] 2
[1] 1
not exists
上一篇:django xadmin(1)


下一篇:使用Nginx反向代理和proxy_cache缓存搭建CDN服务器加快Web访问速度