函数递归/二分法/列表,字典生成式/三元表达式/匿名函数/内置函数

一.递归函数

　　递归函数:就是在函数调用阶段直接或者间接的调用自己

　　递归函数的两个阶段:

　　　　1.回溯:不停的重复的一个过程,在这个过程中将问题不断的简单化,直到最终打到要求(条件)

　　　　2.递归:一次次的往回推导的过程

ps:递归函数不应该无限制二笃递归下去,若不规定递归次数在达到998次左右系统会停止递归

def func(n):
    print('from func',n)
    func(n+1)

func(1)  # from func 998

ps:要想查看次数或者设置递归次数可以使用sys模块

import sys
def func(n):
    print('from func',n)
    func(n+1)
print(sys.getrecursionlimit())  # 默认1000(不精确)
sys.setrecursionlimit(2000)  # 设置次数

a,b,c,d,e,f每个数之间差5 f为20,求其余四个数
def func(n):
    if n == 1:
        return 20
    return func(n-1)+5

到处列表中的每个元素
a=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]]
def func(a):
    for i in a:
        if type(i)  is int:
             print(i)
        func(i)

二.二分法

二分法的使用条件:使用对象为容器类型且其中元素按大小顺序排列a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

def func(a, num):
　　if not a:
　　　　print('请来个有点货的')
　　　　return
    b = len(a) // 2
    if num > a[b]:
        a_r = a[b + 1:]
        func(a_r, num)
    elif num < a[b]:
        a_l = a[:b]
        func(a_l,num)
    else:
        print(num)
func(a,4)

三.三元表达式

三元表达式的固定表达式:

　　值1 if 条件 else 值2

ps:条件成立输出值1,条件不成立输出值2

num = int(input('请输入数字'))
res = 'Odd number'if num % 2 == 1 else  'even number'
print(res)

四.列表,字典生成式

a = [1,2,3,4,5,6,7,6,324,23]
res = [i for i in a if i > 6]
print(res)  # [7, 324, 23]

ps:对列表a进行for循环依次取出列表中的每一个元素,然后进行if条件判断,如果为真则添加到i中若为假则直接丢掉

五.字典生成式

list1 = [1, 2, 3]
list2 = ['first', 'second', 'third']
d={}
for i,j in enumerate(list1):
    d[j] = list2[i]
print(d)  # {1: 'first', 2: 'second', 3: 'third'}

若list1 = [1, 2, 3, 4]
list2 = ['first', 'second', 'third']
d={}
for i,j in enumerate(list1):
    d[j] = list2[i]
print(d)  # 会报错,没有对应的value


若list1 = [1, 2, 3]
list2 = ['first', 'second', 'third','fourth']
d={}
for i,j in enumerate(list1):
    d[j] = list2[i]
print(d)  # {1: 'first', 2: 'second', 3: 'third'}

l1 = ['first', 'second', 'third']
d = {i:j for i,j in enumerate(l1,1) if j != 'second'}
print(d)  # {1: 'first', 3: 'third'}

ps:枚举的编号从1开始,先进行枚举处理,然后拿出j的值进行判断,条件为真则以key:value的形式存储在for之前,若条件为假则丢弃这一组数据

ps:集合生成式

res={i for i in range(10) if i>3}
print(res)  # {4, 5, 6, 7, 8, 9}

元组生成式:

res=(i for i in range(10) if i >3)
print(res)   # <generator object <genexpr> at 0x0000025B7C99D0A0>生成的是一个生成器


for j in res:
    print(j)  # 4 5 6 7 8 9 

六.匿名函数

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

匿名函数的基本式:

lambda x, y: x+y
# lambda是匿名函数的关键字
# 冒号左边的相当于形参
#冒号右边的相当于返回值
ps:匿名函数通常不会单独使用,一般配合内置函数一起使用

 七.常用的内置函数

1.max,min

d={
    'zhagn':100,
    'wang':200,
    'chen':400
}
def index(name):
    return d[name]
print(max(d,key=index))
print(min(d,key=index))
print(max(d,key=lambda name:d[name]))
print(min(d,key=lambda name:d[name]))
#max/min后有2个选项,第一个是对象,第二个是传的是函数,函数返回什么就比较什么,比较的是值返回的还是名字

2.map(映射)

a=[1,2,3,4]
print(list(map(lambda x:x+5,a)))  # [6,7,8,9]
# map后面需添加2个参数,第一个参数是函数,第二个是可迭代对像(容器),基于for循环依次取出a中的值,经过lambda处理后拿到返回值,经过map处理完后是一个生成器,经过list基于for循环取出其中的值

3.zip(拉链)

l1 = [1,2,]
l2 = ['jason','egon','tank']
l3 = ['a']
print(list(zip(l1,l2,l3)))  # [(1, 'jason', 'a'), (2, 'egon', 'b')]
# 处理的对象元素需要意义对应入不满足会被舍弃list处理前也是个生成器,都是基于for循环的
l1 = [1,2,]
l2 = ['jason','egon','tank']
l3 = ['a']
print(list(zip(l1,l2,l3)))  # [(1, 'jason', 'a')] 只有三个都对应上了才会存储,不满足的会被直接丢弃,类似于木桶原理取其最短

4.filter(过滤)

l = [1,2,3,4,5,6]
print(list(filter(lambda x:x != 3,l)))  # 基于for循环 在list处理前也是个生成器,处理后结果为[1, 2, 4, 5, 6]

5.sorted(排序)默认升序

l = ['jason','egon','nick','tank']
print(sorted(l))  # ['egon', 'jason', 'nick', 'tank'] 升序
print(sorted(l,reverse=True))  # 降序['tank', 'nick', 'jason', 'egon']

6.reduce(处理可迭代对像拿到一个结果(一个值))

from functools import reduce
l = [1,2,3,4,5]
print(reduce(lambda x,y:x+y,l,19))  # 传初始值,去对象中的一个元素和初始值相加,把处理结果和第三个数相加以此类推
print(reduce(lambda x,y:x+y,l))   # 不传初始值,直接去对象中的2个元素进行相加,把结果和第三个元素相加依此类推