python学习笔记：第14天 内置函数补充和递归

一、匿名函数

匿名函数主要是为了解决一些简单需求而设计的一种函数，匿名函数的语法为：

lambda 形参： 返回值

先来看一个例子：

# 计算n的n次方
In[2]: lst = lambda n: n ** n         # 这里的lst就是一个匿名函数
In[3]: print(lst(3))
27

使用匿名函数需要注意的几点：

• 函数的参数可以有多个，多个参数之间⽤逗号隔开
• 匿名函数不管多复杂. 只能写⼀⾏, 且逻辑结束后直接返回数据
• 返回值和正常的函数⼀样, 可以是任意数据类型

二、内置函数补充

sorted

sorted是python内置的一个用于排序的函数，它接收三个参数，语法为；

sorted(Iterable， key=None， reverse=False)

• Iterable： 接收一个可迭代对象，sorted内部会去循环可迭代对象取出元素
• key： 排序规则（排序函数），sorted将每次从可迭代对象中取出的数据会传递给这个排序函数的参数，根据函数运算的结果进行排序
• reverse： 控住是否倒叙，True为倒叙，默认为False正序

# 根据字符串⻓度进⾏排序
In[7]: lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
In[8]: lst2 = sorted(lst, key=lambda s: len(s))
In[9]: print(lst2)
['狐仙', '麻花藤', '冈本次郎', '中央情报局']

sorted如果不传作排序用的函数，那么它默认是按照在字符编码中的顺序来排的：

In[10]: lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
In[11]: lst2 = sorted(lst)
In[12]: lst2
Out[12]: ['中央情报局', '冈本次郎', '狐仙', '麻花藤']
In[14]: print(ord('中'))
20013
In[15]: print(ord('冈'))
20872
In[16]: print(ord('狐'))
29392
In[17]: print(ord('麻'))
40635

filter

filter是python中内置的一个过滤的函数，其用法跟sorted差不多：

filter(function, iterable)

• function： ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后
  
  根据function返回的True或者False来判断是否保留此项数据
• iterable： 可迭代对象

In[21]: lst = [{'id':1,'name':'alex','age':28},
   ...: {'id':2,'name':'taibai','age':58},
   ...: {'id':3,'name':'taihei','age':18},
   ...: {'id':4,'name':'henhei','age':38}]

In[22]: ret2 = filter(lambda x: x['age'] >= 38, lst)
   ...: [print(x) for x in ret2]
{'id': 2, 'name': 'taibai', 'age': 58}                # 从结果来看，年龄小于38的都被过滤掉了
{'id': 4, 'name': 'henhei', 'age': 38}

Out[22]: [None, None]

map

映射函数map，使用语法为：

map(function, iterable)

可以对可迭代对象中的每⼀个元素进⾏映射. 分别取执⾏function（其语法和sorted、filter相似）

In[23]: names=['oldboy','alex','wusir']

In[24]: m = map(lambda s: s + '123', names)           # 在每个字符串后加上123

In[25]: print(list(m))                                # map返回的也是一个可迭代对象，使用list会去循环遍历元素
['oldboy123', 'alex123', 'wusir123']

三、递归

在函数中调⽤函数本⾝. 就是递归

def func():
  print("我是谁")
  func()

func()

在python中最大递归深度为1000：

In[26]: import sys

In[27]: sys.getrecursionlimit()           # 虽然我们查询到的结果是1000，但是实际上却跑不到1000，通常是998或者997
Out[27]: 1000

递归的应用：计算斐波那契数列 f(0) = 1 f(1) = 1 f(n) = f(n-1) + f(n-2)

In[35]: def fib(n):
   ...:     if n == 0:
   ...:         return 1
   ...:     if n == 1:
   ...:         return 1
   ...:     return fib(n-1) + fib(n-2)
   ...: 

In[36]: fib(5)
Out[36]: 8

In[37]: fib(10)
Out[37]: 89

总结：

• 递归函数总是涉及到压栈和出栈的过程
• 递归函数总是压栈，知道遇到退出条件，然后出栈
• Python中递归函数有深度限制，可以通过sys.getrecursionlimit()得到深度限制，可以通过sys.setrecursionlimit调整递归深度限制
• 递归函数在Python非常慢，并且有深度限制，所以 因尽量避免使用递归

四、二分法查找

⼆分查找. 每次能够排除掉⼀半的数据. 查找的效率非常⾼. 但是局限性比较⼤. 必须是有

序序列才可以使⽤⼆分查找

• 要求: 查找的序列必须是有序序列

(1) 使用基本的算法实现：

lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

n = int(input("请输入一个数字n:"))      # 56

left = 0                              # 左边界
right = len(lst) - 1                  # 末尾的索引  右边界
while left <= right:                  # 当左边界大于右边界结束循环

    mid = (left + right) // 2         # 求中间的索引坐标
    if n < lst[mid]:                  # 判断你的数字和中间数的大小比较 .
        right = mid - 1               #  右边界往左移动

    elif n > lst[mid]:
        left = mid + 1                # 左边界往右移动

    else:
        print("找到了")               # 找到了目标数字
        break
else:                                 # 当左比右大, 循环结束. 没有找到目标数
    print("没找到")

（2）使用递归实现：

lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

def binary_search(lst, n, left, right):
    if left > right:
        return False
    mid = (left + right) // 2
    if n > lst[mid]:
        left = mid + 1
        # 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
        return binary_search(lst, n, left, right)
    elif n < lst[mid]:
        right = mid - 1
        return binary_search(lst, n, left, right)
    else:
        print("找到了")
        return True

n = int(input("请输入一个数字n:")) # 178
ret = binary_search(lst, n, 0, len(lst)-1)
print(ret)

# 结果：
# 请输入一个数字n:178
# 找到了
# True

切记：当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值

（3）对列表切片：

def binary_search(lst, n):
    if len(lst) == 0:
        return False
    left = 0
    right = len(lst) - 1
    mid = (left + right) // 2
    if n > lst[mid]:
        left = mid + 1
        # 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
        return binary_search(lst[mid+1:], n)
    elif n < lst[mid]:
        right = mid - 1
        return binary_search(lst[:mid], n)
    else:
        print("找到了")
        return True