<h1 id="匿名函数">匿名函数

python定义一个函数通常使用def关键词，后面跟函数名，然后是注释、代码块等。

def func():
    '''注释'''
    print('from func')

这样就在全局命名空间定义了一个叫func的函数，func表示函数体的内存地址，因为func指向函数体内存地址，所以可以通过func来调用函数。

那么匿名函数呢？从名字就可看出，匿名。想想就有点像以前小时候的佚名一样，带点说不清楚的神秘色彩，现在想来之所以感觉神秘可能是因为那时候不认识‘’佚‘’这个字。。。

强调:
    匿名函数的定义就相当于只产生一个变量在值,而没有绑定任何名字,所以会在定义完之后就被回收,无法重复使用,只能在定义时使用一次
应用:当某一个功能仅使用一次就没有再重复使用的必要了,就应该定义成匿名函数

言归正传，匿名和佚名一样没有名字或者不需要知道名字，对就是这么酷。

定义一个匿名函数使用lambda关键词，和def比较的话会发现其实定义逻辑很像。

lambda x: x**2

定义的匿名函数的意思是参数为x，返回x的平方，返回？怎么没看到return？因为lambd引号后面的值默认返回，所以没必要加return了，但是我一定要加呢？就是这么不讲道理。那么解释器只好报错了，因为你不认同我的语法，那我也没必要惯着你了。就是这么拽。

匿名函数的使用场景通常为使用一次就结束了，不会频繁的使用。而且匿名函数通常和python里面自带的高阶函数结合使用，在某些应用场景下会达到事倍功半的效果哦。

map的意思是地图的意思，由此引申出映射表示一一对应。

翻译过来的意思是：创建一个迭代器，使用每个迭代的参数计算函数。 当最短的可迭代用尽时停止。

map函数有两个参数，第一个为某种规则的函数，第二个位多个可迭代对象。

def func(x):
    return x * 2
lis = [1,2,3,4,5,6]
print(type(map(func,lis)))
print(list(map(func,lis)))

map函数把可迭代对象中的元素自动传给func，通过func的加工，得到一个生成器对象，通过list函数转化为一个列表。

当然，map函数可以接收多个可迭代对象，比如

def func(x,y):
    return x + y
lis1 = [1,6]
lis2 = [2,6,7,8,9,10,11]
print(list(map(func,lis1,lis2)))
# 结果为[3,11,13]

map函数会把后面迭代器对象中的元素迭代出来经过func加工，当最短的可迭代用尽是停止，所以只进行到6+7就结束了。

reduce是减少、合并的意思，会把可迭代对象中的元素经过函数的加工进而产生新的结果。

翻译过来就是：从左到右累加两个参数的函数到序列的项目，以便将序列减少为单个值。例如，reduce（lambda x，y：x + y，[1,3] ，4,5]计算（（（（（1 + 2）+3）+4）+5）。如果存在初始值，则将其放置在计算中序列的项之前，并在序列为空时用作默认值。

reduce函数有三个参数，函数和序列都是必须参数，初始值为可选参数。

应用：比如求1-100的和

from functools import reduce
def func(x,y):
    return x+y
print(reduce(func,[i for i in range(1,101)]))
# 结果为 5050

filter的意思为过滤，通过函数的返回值对序列进行过滤。

翻译过来：返回一个迭代器，产生函数（item）为真的迭代项。 如果函数为None，则返回结果为真的项。

def func(x):
    return x.isdigit()
lis = ['12','ad','34','bc','46']
print(list(filter(func,lis)))
# 结果为 ['12','46']

filter过滤结果为真的值放进迭代器中。

在之前map函数中的func参数都是定义了一个有名参数，然后用函数名传入map函数的，有了匿名函数就不用这么麻烦了。

lis = [1,6]
print(list(map(lambda x: x*2,lis)))
# 结果为 [2,12]

print(reduce(lambda x,y: x + y,[i for i in range(101)],100))
# 输出结果为 5050

sala = {
     'MAC': 30000,'iPhone': 9000,'lenovo': 10000,'xiaomi': 3000
}
print(list(filter(lambda x: sala[x] > 5000,sala)))
# 输出结果为 [‘iPhone','lenovo']

匿名函数的使用场景较为单一，一次性使用，随用随时定义。在某些场景下和高阶函数结合会提升效率，同时使代码更加简洁。

递归调用时函数嵌套调用的一种特殊形式，函数在调用时，直接或间接地调用了自身，就是递归调用。

# 直接调用自身
def f1():
    print('from f1')
    f1()
f1()
间接调用自身
def f1():

print('from f1')

f2()
def f2():

print('from f1')

f1()

f2()
调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无限调用自身，python解释器的内存管理机制为了防止无限占用内存，对函数的递归调用做了层级限制，可以通过代码修改最大层级限制。
import sys

sys.setrecursionlimit(100000)

<h2 id="二-递归调用的两个阶段">二 递归调用的两个阶段

递归调用包含两个明确的阶段：回溯，递推

• 回溯就是从外向里一层一层递归调用下去，回溯阶段必须要有一个明确的结束条件（不然会成为死循环），每进入下一次递归时，问题的规模都应该有所减少。

• 递推就是从里向外一层层结束递归。

• 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈实现的，每当进入一个函数调用，在栈下面会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以递归调用次数过多，会导致栈溢出）

从一个排序的数字列表中找到指定的数字，使用遍历的效率太低，使用二分法可以极大地缩小问题规模。

1. 实现in的效果

   nums = [1,12,23,34,46,59,99,443]
   def fucn(num,nums):
   
   if len(nums) == 0:
   
   return
   
   mid_index = len(nums) // 2
   
   if num > nums[mid_index]:
   
   nums = nums[mid_index+1:]
   
   fucn(num,nums)
   elif num < nums[mid_index]:
       nums = nums[:mid_index]
       fucn(num,nums)
   else:
       print('not exis')</code></pre>
   

2. 实现index的效果

   nums = [1,13,15,27,31,33,57,73,81,93,94,97,101]  # 从小到大排列的数字列表
   def binary_search(find_num,nums):
       print(nums)
       if len(nums) == 0:
           print('not exists')
           return
   # 功能
   mid_index = len(nums) // 2
   if find_num > nums[mid_index]:
       # in the right
       nums=nums[mid_index+1:]
       # 重新运行功能,传入新列表
       binary_search(find_num,nums)
   elif find_num < nums[mid_index]:
       # in the left
       nums=nums[:mid_index]
       # 重新运行功能,nums)
   else:
       print('find it')
   binary_search(95,nums)

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!