函数--补充

函数补充

• 函数补充
  • 递归函数
  • 算法二分法
  • 三元表达式
  • 列表生成式
  • 字典生成式
  • 匿名函数
  • 常用内置函数

递归函数

函数在执行过程中直接或间接调用了本身

官方表示：python默认最大递归深度为1000次，但实际是997，998

'''
count = 1
def index():
    global count
    count +=1
    print(count)
    print('from index')
    index()
index()

递归：
	1.递推
		一层层往下推导答案（每次递归之后复制都要相较与上一次要有所下降）
	2.回溯
		依据最后的结论往后推导出最初需要的答案
	递归一定要有结束条件
'''

age(5) = age(4) + 2
age(4) = age(3) +2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 5
伪代码虽然无法运行，但是可以说清楚逻辑

def get_age(n):
    if n == 1:
        return 18
    return get_age(n - 1) + 2
print(get_age(5))


l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,]]]]]]]]]]]]]]
def get_num(l):
    for i in l:
        if type(i) is int:
            print(i)
        else:
            get_num(i)
get_num(l)

算法二分法

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

# 什么是算法?
	解决问题的高效方法
   
# 二分法(入门级别:还有一定距离)
	l = [11, 23, 43, 57, 68, 76, 81, 99, 123, 321, 432, 567, 666, 712, 899, 999, 1111]
# 第一种方式  直接for循环从左往右依次查找

# 第二种方式  二分法
"""
二分法能够使用的场景  数据集必须有序
"""
def my_partner(target_num, l):  # target_num=321  l=l
    if len(l) == 0:
        print('不好意思 我尽力 没找到')
        return
    # 先获取中间位置索引值
    middle_index = len(l) // 2  # 8
    # 判断中间索引对应的值比目标值大还是小
    if target_num > l[middle_index]:
        # 说明要找的元素只可能出现在列表的右侧
        l_right = l[middle_index + 1:]  # l[9:]
        print(l_right)
        my_partner(target_num, l_right)
    elif target_num < l[middle_index]:
        # 说明要找的元素只可能出现在列表的左侧
        l_left = l[:middle_index]
        print(l_left)
        my_partner(target_num, l_left)
    else:
        print('找到了', target_num)
# my_partner(444, l)  找不到 需要添加结束条件
# my_partner(11, l)  # 要查找的元素在开头  那么还没有依次查找的效率高

三元表达式

def my_max(a,b)
	if a > b:
        return a
    else:
        return b
'''
当功能需求仅仅是二选一的情况下，推荐三元表达式
'''

def my_max(a,b)
return a if a > b esle b	#条件成立采用if前面的值不成立采用后面的

三元表达式可以嵌套但不推荐
res = '吃饭' if 10 > 5 else '不吃'
print(res)
res = '吃饭' if 10 > 20 else ('不管' if 3 > 4 else 'gun' )
print(res)

列表生成式

给所有人的后缀加上
name_list = ['jason', 'tony', 'danny', 'kevin',']

res = ['%s_nb' % name for name in name_list]
print(res)
             
生成新的列表            
res = ['%s_DSB' % name for name in name_list if name != 'jason']
print(res)

字典生成式

枚举
'''
enumerate(11)
针对该方法使用for循环取值，每次否会产生两个结果
	第一个是从0 开始的数字
	第二个是被循环对象里面的元素
还可以通过start参数控制起始位置
'''
name_list = ['jason', 'kevin', 'tony', 'jerry']
res = {i: j for i, j in enumerate(name_list) if j != 'jason'}
print(res)

res1 = {i for i,j in enumerate(name_list)}
print(res1,type(res1))

匿名函数

没有名字的函数

语法格式

? lambda 形参：返回值

print((lambda x:x**2)(2))
def index():
    pass
print(index)
print((lambda x: x ** 2)(2))
res = lambda x: x**2
print(res(2))


'''匿名函数一般不会单独使用 都会配合其他函数起义使用'''

常用内置函数

1.map()	映射
    l = [1, 2, 3, 4, 5, 6, 7, 8]
    def index(n)：
        return n ** 2
    print(list(map(lambda x:x**2, 1)))

    l = [1, 2, 3, 4]
    map(lambda x:x+1,1)  #循环过去列表中的每个元素并传递给匿名函数
    
2.zip()	拉链
	l = [11, 22, 33, 44, 55, 66, ]
    name_list = ['jason', 'kvein', 'tony', 'jerry']
    l1 = [1, 2, 3, 4, 5, 6, 7]
	l2 = [8, 7, 6, 4, 3, 2, 1]
    res = zip(l, name_list, l1, l2)
    print(list(res))
    
3.max与min max求最大值 min 求最小值
    l = [11, 22, 33, 44, 55]
    print(max(1))
    print(min(1))

    d = {
        'jason':3000,
        'Kevin':123123,
        'Ascar':1312342,
    }
    def index(key):
        #     return d[key]
    # print(max(d,key=lambda key:d[key]))  # for循环先取值 之后再比较大小
    """
    A-Z  65-90
    a-z  97-122
    """
    # print(min(d,key=lambda key:d[key]))  # jason
    
4.filrer 过滤
    l = [11, 22, 33, 44, 55]
    res = filter(lambda x:x > 30 ,1)
    print(list(res))		#[33, 44, 55]

5.reduce 归总
	from functools import reduce
    d = [11, 22, 33, 44, 55, 66, 77, 88, 99]
    res = reduce(lambda x, y: x + y, d)
    res1 = reduce(lambda x, y: x + y, d, 100)  # 还可以额外添加元素值
    print(res)