递归函数和匿名函数

# 1. 递归函数

# 1.1 递归的定义

什么是递归：在一个函数里调用这个函数本身

def  foo():
    print(n)
    n+=1
    foo(n)
foo(1)

1
2
3
4
5

最大递归层数限制：997

是python默认的，可以做修改，但是不建议你修改。（因为如果用997层递归都没有解决的问题，要么是不适合使用递归来解决，要么就是你的代码太烂了0.0）

import sys
sys.setrecursionlimit(10000000) #修改递归层数
n=0
def f():
    global n
    n+=1
    print(n)
    f()
f()

1
2
3
4
5
6
7
8
9

结束递归的标志：return
递归解决的问题：通过参数，来控制每一次调用缩小计算的规模
使用场景：数据的规模在减少，但是解决问题的思路没有改变
很多排序算法会用到递归

# 1.2 递归小应用

猜小明的年龄

小明是新来的同学，丽丽问他多少岁了。

他说：我不告诉你，但是我比滔滔大两岁。

滔滔说：我也不告诉你，我比晓晓大两岁

晓晓说：我也不告诉你，我比小星大两岁

小星也没有告诉他说：我比小华大两岁

最后小华说，我告诉你，我今年18岁了

这个怎么办呢？当然，有人会说，这个很简单啊，知道小华的，就会知道小星的，知道小星的就会知道晓晓的，以此类推，就会知道小明的年龄啦。这个过程已经非常接近递归的思想了。


小华	18+2
小星	20+2
晓晓	22+2
滔滔	24+2
小明	26+2

上面的图我们可以用个序号来表示

age(5) = age(4)+2
age(4) = age(3) + 2 
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18

1
2
3
4
5

那么代码该怎么写呢？

def age(n):
    if n == 1:
        return 18
    else:
        return age(n - 1) + 2

ret=age(6)
print(ret)

1
2
3
4
5
6
7
8

一个数，除2直到不能整除

def cal(num):
    if  num%2==0:#先判断能不能整除
        num=num//2
        return cal(num)
    else:
        return num
print(cal(8))

1
2
3
4
5
6
7

如果一个数可以整除2，就整除，不能整除就*3+1

如果一个数可以整除2，就整除，不能整除就*3+1

def func(num):
    print(num)
    if num==1:
        return
    if num%2==0:
        num=num//2
    else:
        num=num*3+1
    func(num)
func(5)

1
2
3
4
5
6
7
8
9
10

# 1.3 二分查找法

从这个列表中找到55的位置

l=[2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

这就是二分查找，从上面的列表中可以观察到，这个列表是从小到大依次递增的有序列表。按照上面的图就可以实现查找了。

简单二分法

l = [2, 3, 5, 10, 15, 16, 18, 22, 26, 30, 32, 35, 41, 42, 43, 55, 56, 66, 67, 69, 72, 76, 82, 83, 88]
def find(l,aim):
    mid=len(l)//2 #取中间值，//长度取整（取出来的是索引）
    if l[mid]>aim: #判断中间值和要找的那个值的大小关系
        new_l=l[:mid] #顾头不顾尾
        return find(new_l,aim) #递归算法中在每次函数调用的时候在前面加return
    elif l[mid]<aim:
        new_l=l[mid+1:]
        return find(new_l,aim)
    else:
        return l[mid]
print(find(l,66))

1
2
3
4
5
6
7
8
9
10
11
12

升级版二分法

l = [2, 3, 5, 10, 15, 16, 18, 22, 26, 30, 32, 35, 41, 42, 43, 55, 56, 66, 67, 69, 72, 76, 82, 83, 88]
def func(l, aim,start = 0,end = len(l)-1):
    mid = (start+end)//2#求中间的数
    if not l[start:end+1]:#如果你要找的数不在里面，就return'你查找的数字不在这个列表里面'
        return  '你查找的数字不在这个列表里面'
    elif aim > l[mid]:
        return func(l,aim,mid+1,end)
    elif aim < l[mid]:
        return func(l,aim,start,mid-1)
    elif aim == l[mid]:
        print("bingo")
        return mid

index = func(l,55)
print(index)
# print(func(l,41))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 2. 匿名函数

匿名函数：也叫lambda表达式

**匿名函数的核心：**一些简单的需要用函数去解决的问题，匿名函数的函数体只有一行。参数可以有多个，用逗号隔开。返回值和正常的函数一样可以是任意的数据类型

匿名函数练习

函数转变为匿名函数

#把下面的函数转换成匿名函数
def  add(x,y)
        return x+y
add()

#结果：
sum1=lambda x,y:x+y
print(sum1(5,8))

1
2
3
4
5
6
7
8

比大小

dic = {'k1':50,'k2':80,'k3':90}
# func= lambda k:dic[k]
# print(max(dic,key=func))
print(max(dic,key = lambda k:dic[k])) #上面两句就相当于下面一句

1
2
3
4

map方法的应用

l=[1,2,3,4]
# def func(x):
#     return x*x
# print(list(map(func,l)))
print(list(map(lambda x:x*x,l)))

1
2
3
4
5

filter函数的小应用

l=[15,24,31,14]
# def func(x):
#         return x>20
# print(list(filter(func,l)))

print(list(filter(lambda x:x>20,l)))

1
2
3
4
5
6

现有两个元组(('a'),('b'))，(('c'),('d'))，请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

# 方法一
t1=(('a'),('b'))
t2=(('c'),('d'))
# print(list(zip(t1,t2)))
print(list(map(lambda t:{t[0],t[1]},zip(t1,t2))))

# 方法二
print(list([{i,j} for i,j in zip(t1,t2)]))

#方法三
func = lambda t1,t2:[{i,j} for i,j in zip(t1,t2)]
ret = func(t1,t2)
print(ret)

1
2
3
4
5
6
7
8
9
10
11
12
13

列表推导式

#30以内所有被3整除的数
print(list([i for i in range(30) if i%3==0]))

1
2

字典推导式

例一：将一个字典的key和value对调

mcase = {'a': 10, 'b': 34}
res1 = {i:mcase[i] for i in mcase}
res={mcase[i]:i for i in mcase }
print(res1)
print(res)

1
2
3
4
5

例二：合并大小写对应的value值，将k统一成小写

mcase = {'a':10,'b':34,'A':7}
res = {i.lower():mcase.get(i.lower(),0)+mcase.get(i.upper(),0) for i in mcase}
print(res)

1
2
3

集合推导式

例：计算列表中每个值的平方，自带去重功能

l=[5,-5,1,2,5]
print({i**2 for i in l})

1
2

上次更新: 2023/07/05, 16:57:02

← 装饰器-迭代器-生成器内置函数→