Day 12 递归,二分算法,推导式,匿名函数

1.递归函数:函数在调用阶段直接或间接的调用自己,函数不应该无休止的递归下去

1. 　　sys 模块

   import sys
   print(sys.getrecursionlimit())   # 递归深度  # 1000
   sys.setrecursionlimit(2000)  # 设置递归深度
   print(sys.getrecursionlimit()) # 2000

2. 递归实例

# 编写一个计算阶乘的函数

def func(n):
    if n == 1:
        return 1
    return func(n - 1) * n
print(func(5))

# 将下面列表中的数字打印出来 # l = [1, [2, [3, [4, [5, [6, [7]]]]]]]

def f(l):
    for i in l:
        if type(i) is int:
            print(i,end=' ')
        else:
            f(i)
l = [1, [2, [3, [4, [5, [6, [7]]]]]]]
f(l)

# 第n个斐波那契数
def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n-1) + f(n-2)

print(f(20))

2.二分算法: 算法是解决问题的高效率方法,二分算法必须是针对数字有大小顺序的容器:   折办查找

实例:

def func(l):
    index = len(l)//2
    if l[index] > x:
        ll = l[index+1:]
        func(ll)



    elif l[index] < x:
        lr = l[:index]
        func(lr)
    else:
        return index

l =[1,2,3,4,5,56,67,87]
x = 5
print(func(l))

3 推导式:

1. 三元表达式:当条件满足时返回if前面的. 不满足则返回else后面的.只适用于只有两种情况的情况下..语法如下

   x, y = 5, 6
   res = x if x > y else y  # 若x > y返回 x,否则返回 y
   print(res)

    

2. 列表生成式: 用[ ] 控制for 循环逐个取出列表中的元素交给for前面的语句逐个处理后生成一个新的列表,若存在if判断会先逐个交给if判断,条件满足后才会交给for 前面的语句.

   l = [1, 2, 3, 4, 5, 6]
   l1 = [i + 1 for i in l]
   print(l1)  # [2, 3, 4, 5, 6, 7]
   l2 = [i + 1 for i in l if i != 3]
   print(l2)  # [2, 3, 5, 6, 7]

    

3. 字典生成式:  用{}  通过for循环枚举取出列表中的元素组成键值对然后组成字典,若存在if判断会先逐个交给if判断

   l = ['name', 'age', 'addr']
   dic = {i:j for i,j in enumerate(l)}
   print(dic)  # {0: 'name', 1: 'age', 2: 'addr'}
   dic1 = {i:j for i,j in enumerate(l) if j != 'age'}
   print(dic1)  # {0: 'name', 1: 'age', 2: 'addr'}

   enumerate() 枚举补充: 将两个列表对应的元素组成一个字典

   l = ['name', 'age', 'addr']
   l1 = ['jay', '25', 'china']
   dic = {}
   for i,j in enumerate(l):
       dic[j] = l1[i]
   print(dic)  # {'name': 'jay', 'age': '25', 'addr': 'china'}

    

4.匿名函数:没有名字的函数,他是临时存在用完就没有了, 用lambda定义,左边的相当于函数的形参,右边的相当于返回值,匿名函数 　　通常不会单独使用,通常配合内置函数使用

def my_sum(x,y):
    return x + y
# 他俩是等价的
my_sum = lambda x, y : x + y

5.内置函数:

1. map()  映射:map()函数接收两个参数,一个是函数,一个是序列,map将传入的函数基于for循环依次作用到序列的每个元素，并把结果作为迭代器返回

   l = [1, 2, 3, 4, 5]
   print(list(map(lambda x : x ** 2,l )))  # [1, 4, 9, 16, 25]

    

2. zip()  拉链: 将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回一个迭代器。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

   l1 = [1,2,]
   l2 = ['!','@','#']
   l3 = ['a','b','c']
   
   print(list(zip(l1,l2,l3)))  # [(1, '!', 'a'), (2, '@', 'b')]

    

3. filter()  过滤 接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，将返回False的元素过滤

   l = [1,2,3,4,5,6]
   print(list(filter(lambda x:x != 3,l)))  # [1, 2, 4, 5, 6]
   # 过滤掉列表中x == 3 的元素

    

4. sorted()  排序 list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

   l = [1, 5, 2, 8, 9, 0]
   l1 = sorted(l)
   print(l)   # [1, 5, 2, 8, 9, 0]
   print(l1)  # [0, 1, 2, 5, 8, 9]

    

5. reduce()  用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。当有初始值时.先用初始值与第一个元素操作

   from functools import reduce
   l = [1,2,3,4,5]
   l1 = reduce(lambda x,y : x +y, l)   # 15
   l2 = reduce(lambda x,y : x + y, l,6)  # 21
   print(l1 , l2)