2019-07-12 函数递归、二分法、匿名函数、三元表达式、内置函数

1、递归函数

　　我理解为递归函数也是函数嵌套的一种，函数在调用时，直接或间接的调用了自身。

　　简单的直接调用自己（这种调用会一直循环下去，会很占内存空间，因此python解释器为了防止无限占用内存，对这种循环作出了限制，循环到必定程度就会自动中止）

def f1():
    print('f1')
    f1()
f1()

　　递归调用分为两个阶段：回溯、递推

　　回溯：回溯是外层向里一层层调用下去。回溯阶段必需要有一个明确的结束条件，每次进入下一次递归，问题的复杂度都应该下降（不然，单纯的重复调用自身是毫无心义的）

　　递推：递推是里层向外一层层结束递归

def age(n):
    if n == 1:  # 必需要有结束条件
        return 18
    return age(n-1) + 2
res = age(5)
print(res)

递归函数不须要考虑循环的次数，只须要把握结束的条件

2、算法之二分法

　　算法：快速高效的解决问题的方法

　　有这样一个列表 l =[1,2,3,4,5,6],假如你须要找到数字6，咱们以前的作法是for循环全部数字，而后比较。这种作法对小数据还好，若是是很大的数据，咱们要查找的数据还在最后一个，若是咱们用for循环的方法查找就很影响效率。因此这里咱们用二分法。

l = [1,3,5,12,57,89,101,123,146,167,179,189,345]

#快速找到345
tag_num = 344
def get_num(l,tag_num):
    #判断若是没有这个数字
    if not l:
        print('没有这个数字')
        return
    #咱们先须要把列表从小到大排序
    l.sort()
    print(l)
    #咱们先用len的方法先获取中间值的索引
    num_index = len(l)//2
    #进行比较，若是目标数大于中间数，就往右边找
    if tag_num > l[num_index]:
        #把右边的全部数字用切片的方式截取出来
        num = l[num_index+1:]
        get_num(num,tag_num)    #而后咱们把右边截取出来的列表再从中间分开，接下来的步骤就是重复的
    #截取左边的数字
    elif tag_num < l[num_index]:
        num = l[0:num_index]
        get_num(num,tag_num)
    else:
        print('find it')

get_num(l,tag_num)

二分法快速找到列表中的数字

3、三元表达式

　　三元表达式固定表达式：

　　值 1 if 条件 else 值 2

　　　　条件成立   值1

　　　　条件不成立  值2　　　

　　x > y条件成立就返回x　

x = 99999
y = 9898898
res = x if x > y else y
print(res)

　　　　三元表达式不建议嵌套使用，推荐在只有两种状况下使用，嵌套多了容易出错

4、列表生成式

#原始方法，往列表中的每一个元素末尾都加上_sb
l = ['tank','nick','oscar','sean']
l1 = []
for name in l:
    l1.append('%s_sb'%name)
print(l1)

#列表生成式的方法作
l = ['tank','nick','oscar','sean']
#for循环先取出每一个元素i,而后在每一个元素后面加_sb，字符串拼接
res = [ '%s_sb' %i for i in l]
print(res)     #['tank_sb', 'nick_sb', 'oscar_sb', 'sean_sb']

　　先for循环取出列表中的每个元素，而后交给if判断，符合要求的才会交给for前面的代码，若是条件不成立当前的元素直接舍弃。

l = ['tank_sb', 'nick_sb', 'oscar_sb', 'sean_sb','jason_NB']
#每一个元素取出来，末尾以_sb结尾的才符合要求加入到列表中
res = [i for i in l if i.endswith('_sb')]

print(res)

5、字典生成式

l1 = ['jason','123','read']
d = {i:j for i,j in enumerate(l1) if j != '123'}   #j不符合，i也会删除
print(d)    #{0: 'jason', 2: 'read'}

#集合生成式
res = {i for i in range(10) if i!=3}   #条件i不等于3就是成立
print(res)    #{0, 1, 2, 4, 5, 6, 7, 8, 9}

   res1 = (i for i in range(10) if i != 4)  # 这样写不是元组生成式 而是生成器表达式

6、匿名函数    没有名字的函数

　　匿名函数的特色：临时存在用完就没了

　　后面的括号就至关于设置参数，x,y能够当作函数的形参，x+y能够当作函数的返回值。

　　匿名函数一般不会单独使用，通常会和内置函数一块儿使用

res = (lambda x,y:x+y)(5,2)
print(res)

7、内置函数

　　max ()  返回最大值    内部是基于for循环的      min()返回最小值

#简单的
l = [1,2,3,4,5]
print(max(l))


#字典根据最大的value返回对应的key
d = {
    'egon':30000,
    'jason':88888888888,
    'nick':3000,
    'tank':1000
}
print(max(d))   #由于max也是基于for循环的，这个只会返回key

res = max(d,key=lambda name:d[name])
print(res)  #jason    #max还有一个参数，key写函数根据value来排大小，返回的值是d　

map zip filter sorted reduce

　　map()   映射  将传入的函数依次做用到序列的每一个元素

　　这个匿名函数功能是每一个元素都加5，而后放在一个列表中

l = [1,2,3,4,5,6]

print(list(map(lambda x:x+5,l)))    #[6, 7, 8, 9, 10, 11]

　　zip()   拉链（配对）  若是少了，会匹配最短的那个个数

l1 = [1,2,]
l2 = ['jason','egon','tank']
l3 = ['a','b','c']
print(list(zip(l1,l2,l3)))    #[(1, 'jason', 'a'), (2, 'egon', 'b')]

　　filter()   过滤  基于for循环   把不符合的去掉

l = [1,2,3,4,5,6]
res = filter(lambda x:x!=3,l)
print(list(res))     #[1, 2, 4, 5, 6]

　　sorted()  排序     后面加了reverse就是反转

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

print(res)    #[6, 5, 4, 3, 2, 1]

　　reduce()   序列求和    必须包含两个参数，一个是函数，一个是序列，后面若是再加参数就当初始值和序列中的数相加。

from functools import reduce
l = [1,2,3,4,5,6]
print(reduce(lambda x,y:x+y,l,19))   #40#这里初始值是19，第一次先获取两个元素的和19和1，以后每获取一个与上一次相加的结果再相加