函数(四)

1.函数递归

什么是函数递归

　　函数递归是函数嵌套的一种,是在函数调用阶段,直接或者间接的又调用自身

函数递归的演示

直接调用自身

def func(n):
    print('递归函数的演示%s'%n)
    print(n)
    func(n+1)  # 又调用了本身
func(1)

间接调用自身

# index()函数内部调用了func()函数
def index(n):
    print(n)
    func(n+1)
    print(n)
# func()函数内部又调用了index()函数,导致了递归出现了死循环
def func(n):
    print(n)
    index(n+1)

index(1)

在函数内部又调用了自身,导致了重复调用,类似死循环,但是为了防止内存的溢出,python解释器对函数的递归做了限制,大概只能递归998次左右

我们可以通过添加sys模块人为的更改递归的限制此时

# sys模块
import sys
print(sys.getrecursionlimit())  # 输出递归限制
sys.setrecursionlimit(2000) # 可以更改递归限制

 

函数递归的运用

递归可以在函数内帮我们完成类似循环的操作,但是我们不可能让一个函数无限制的递归下去,这时候我们需要给递归限制一个条件

递归分为两个阶段

　　回溯:函数递归时必须有一个明确的结束条件,并且每次递归的问题复杂程度慢慢下降,这样才能解决问题,否则便是毫无意义的死循环

　　递推:到达结束条件之后,一步步的往回推,获取最终结果

问题1:第一个人是20岁,他比第二个人小2岁,以此类推第10个人是多少岁

'''
age1 = 20
age2 = age1 + 2
age3 = age2 + 2
age4 = age3 + 2
...
age(n) = age(n-1) + 2
'''
def index(n):
    if n == 1:  # 结束条件
        return 20
    return index(n-1)+2

res = index(10)

问题2:循环输出l = [1,[2,[3,[4,]]]]

l = [1,[2,[3,[4,]]]]
for i in l:
    if type(i) is int:
        print(i)
    else:
        for i1 in i:
            if type(i1) is int:
                print(i1)
            else:
                for i2 in i1:
                    if type(i2) is int:
                        print(i2)
                    else:
                        for i3 in i2:
                            if type(i3) is int:
                                print(i3)

可以使用for循环来输出,但是这样做很繁琐,一旦数字过大,便很难输出结果

利用递归解决

def index(l):
    for i in l:
        if type(i) is int:
            print(i)
        else:
            index(i)
index(l)

注意:

　　使用递归函数不要考虑循环的次数 只需要把握结束的条件即可

2.算法之二分法

什么是算法

　　算法是解决问题高效的方法

问题:求一个数是否在一个列表中

l = [1,2,3,4,5,6,7,8,9]
x = 9
print(x in l)  # 第一种
for i in l:  # 第二种
    if x == i:
        print('%s在列表中'%x)
    else:
        pass

这两种方法都是基于for循环,即把每个数字都取出来一个个的进行对比,如果要求的是最后一个数字,则需要比较9次,这样的效率比较低

 

二分法查找:在有序列表中,先求出列表中间那个数,与被比较数比较,如果大于被比较数,则把小于中间数的数字作为列表,再求这个列表的中间数,再进行比较,直至找到这个数,这样的方法查找次数减少,查找效率提高

用二分查找法查找一个数

l = [1,2,3,4,5,6,7,8,80,100]
def index(x,l):
    if not l:
        print('%s这个数不在列表中'%x)
        return
    key = len(l)//2  # 求列表中间的索引
    if x > l[key]:  # 与列表中间索引对应的值进行比较
        l_right = l[key + 1:]  # 比中间的值大就取右半区
        index(x,l_right)
    elif x < l[key]:
        l_left = l[0:key]  # 比中间的值小就取左半区
        index(x,l_left)
    else:
        print('%s在列表中'%x)  # 相等就打印
index(80,l)

注意:用二分法查找的列表一定是有大小顺序的

3.三元表达式

函数求数字大小

def my_max(x,y):
    if x > y:
        return x
    else:
        return y

res = my_max(5,9)
print(res)

三元表达式求数字大小

x = 4
y = 3
res1 = x if x > y else y  # 三元表达式表示的是如果条件成立就返回x,条件不成立就返回y
print(res1)

三元表达式的固定格式

# 三元表达式的格式:
    值/代码1 if 布尔值判断 else 值/代码2 
        如果条件成立布尔值为True 则 输出值/代码块1
        如果条件不成立布尔值为False 则 输出值/代码块2

注意:三元表达式只推荐在只有两个情况的条件下使用,一旦超过两个情况,代码块会变得复杂,不适合使用

4.列表生成式

输出一个新列表,并且在每个元素后面添加123

l = ['sss','xxx','ccc','111']
# 普通的方法
l1 = []
for name in l:
    l1.append('%s123'%name)  # 循环输出每个元素,并在每个字符串后面添加123,再添加入新列表
print(l1)

 用列表生成式,在每个元素后面添加1234

# 列表生成式的方法
l1 = ['%s1234' %name for name in l]  # 直接用列表生成式生成新列表
print(l1)

列表生成式后也可以跟if判断式

l2 = ['%s' %name for name in l1 if name.isdigit() == False]  # 把不是纯数字的元素添加到新列表中
print(l2)

先for循环输出列表中的每个元素
交由if判断,条件成立的元素放入新列表
条件不成立的元素直接舍弃

注意:if后面不能再跟else,因为for后面也有else的说法,这样程序不能判断是for的else还是if的else

5.字典生成式和集合生成式

传统方法把两个列表一一对应生成一个字典

# 字典集合生成式
l1 = ['name','pwd','age']
l2 = ['sxc','123','18','123']
d = {}
for i,j in enumerate(l1):  # 枚举,i相当于列表的索引,j是列表的元素
    print(i,j)
    d[j] = l2[i]
print(d)

字典生成式

d1 = {i:j for i,j in enumerate(l1,1)}  # 字典生成式生成列表
print(d1)
d2 = {i:j for i,j in enumerate(l2,1) if i != 2}  # 加if判断条件的表达式,把i==2的情况去掉,后面也不能跟else
print(d2)

注意:和列表生成式类似,字典生成式后也可以跟if判断条件,也不能再跟else

集合生成式

s1 = {i for i in range(10)}  # 集合生成式
print(s1)
s2 = {i for i in range(10) if i != 5}  # 集合生成式加if判断条件,后面也不能跟else
print(s2)

注意:和列表生成式类似,集合生成式后也可以跟if判断条件,也不能再跟else

生成式表达式:没有元组生成式,只有生成式表达式(相当于一个老母猪)

t1 = (i for i in range(10) if i != 6)  # 这样写不是元组生成式,而是生成器表达式,相当于老母猪
print(t1)
for i in t1:
    print(i)

6.匿名函数

匿名函数不再使用def的标准定义一个函数,而是使用lambda来创建匿名函数,匿名函数顾名思义是没有函数名的函数

匿名函数有自己的名称空间,并且只能访问自己参数列表的名称,不能访问其他或者全局名称空间的名称

匿名函数lambda只是一个表达式,函数体比def简单的多,并且他只能封装有限的逻辑表达式

匿名函数的特点:临时存在,用完就没了

求两个数的和

def sum(x,y):
    return x + y
res = sum(1,2)
print(res)

匿名函数求和

res1 = (lambda x,y:x+y)(3,4)  # 匿名函数的第一种写法
print(res1)
res3 = lambda  x,y:x+y  # 匿名函数的第二种写法
print(res3)  # 这是函数对应的地址空间
print(res3(5,6))

匿名函数的语法:(匿名函数lambda　匿名函数对应的形参  :   匿名函数对应的返回值)(匿名函数的实参)

匿名函数通常不会单独使用,是配合内置函数一起使用的

7.常用的内置函数

Python内置函数有很多

常用的一共约有69个内置函数

max()函数

　　max(x,y,z...) 方法返回给定参数的最大值，参数可以为序列,内部是基于for循环的

l = [1,2,3,4,5]
print(max(l))  # 求最大值,内部是基于for循环的

max()+内置函数lambda的运用

d = {
    'sxc':30000,
    'zzj':88888888888,
    'zzp':3000,
    'lzx':1000
}
# 求value的最大值,返回对应key的值
print(max(d,key = lambda name :d[name]))
# 求value的最小值,返回对应key的值
print(min(d,key = lambda name :d[name]))

map(函数,一个或多个序列)映射

　　按照序列的索引执行前面的函数

l1 = [1,2,3,4,5]
l2 = [5,4,3,2,1]
res = map(lambda x,y:x+y,l1,l2)  # 定义一个匿名函数,输入两个列表按照索引执行函数
print(list(res))

zip(可迭代的对象)拉链

　　把多个迭代器内的内容按照索引分别组合成一个个元组,也是基于for循环的

l1 = ['姓名:sxc','姓名:zzj','姓名:zzp']
l2 = ['年龄:18','年龄:19','年龄:20']
l3 = ['密码:123','密码:234','密码:345']
res = zip(l1,l2,l3)
print(res)  # 老母猪
print(list(res))  # 可以用list来转换输出列表

filter(判断布尔值的函数,可迭代的对象)

　　用函数判断可迭代的对象的True和False,True的输出,False的丢弃

l = [9,7,5,3,1]
res = filter(lambda x:x > 4,l)  # 输出布尔值为True的l中的元素
print(res)
print(list(res))

sorted(可迭代对象,key,reverse)升序,降序

　　对可迭代对象的升序降序,reverse = True降序,reverse = False升序

　　sorted与list.sort的不同是前者重新创建了一个列表,后者把原列表重新声明了,相当于修改了原列表

l = [1,2,3,4,5,6]
res = sorted(l,reverse=True)  # 降序
print(res)

reduce(函数,可迭代对象,初始值) 函数会对参数序列中元素进行累积

　　两个及以上的可迭代对象的数据按照函数累积,可以指定初始值

from functools import reduce
l = [1,2,3,4,5,6]
res = reduce(lambda x,y:x+y,l)  # 不指定初始值1+2+3+4+5+6
print(res)
res1 = reduce(lambda x,y:x+y,l,100)  # 初始值指定为100,100+1+2+3+4+5+6
print(res1)

 12