函数递归，匿名函数

                                           函数递归

'''
1 什么是函数递归
    函数递归调用（是一种特殊的嵌套调用）：在调用一个函数的过程中，又直接或间接地调用了该函数本身

    递归必须要有两个明确的阶段：
        递推：一层一层递归调用下去,强调每进入下一层递归问题的规模都必须有所减少
        回溯：递归必须要有一个明确的结束条件，在满足该条件时结束递推
            开始一层一层回溯

    递归的精髓在于通过不断地重复逼近一个最终的结果

2、为什么要用函数递归


3、如何用
'''


# import sys
# print(sys.getrecursionlimit())
# sys.setrecursionlimit(3000)             #最大递归数是1000
# def foo(n):
#     print('from foo',n)
#     foo(n+1)
# foo(0)                   #直接的调用函数本身，先调用函数foo()后，执行代码，先打印，到foo(n+1)又调用了函数，然后再打印，再调用，一直循环

# def bar():
#     print('from bar')
#     foo()
#
# def foo():
#     print('from foo')
#     bar()

# foo()              #间接的调用函数本身

#举例：求出第五个人的年龄
# age(5) = age(4) + 2
# age(4) = age(3) + 2
# age(3) = age(2) + 2
# age(2) = age(1) + 2
# age(1) = 26

# age(n) = age(n-1) + 2 #n > 1
# age(1) = 26           #n = 1


# def age(n):
#     if n == 1:
#         return 26
#     return age(n-1) + 2    #拿到返回值，返回给age(n)
#
# print(age(5))

# 举例：把下面列表里面的每一个值都取出来。
# l=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
#
# def tell(l):
#     for item in l:
#         if type(item) is list:
#             #继续进入下一层递归
#             tell(item)    #调用自身函数，递归进行下一层循环
#         else:
#             print(item)
#
# tell(l)

# 举例：有一个从小到大排列的整型数字列表，找到10
# 方法一：循环的方法
# nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
# 10 in nums
# for item in nums:
#     if item == 10:
#         print('find it')
#         break
# else:              #如果for循环都遍历完了，都没有被break掉，就执行else
#     print('not exists')

# 方法二：二分法。   想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模
# 逻辑思路：先找要找的值----判断列表是否为空，则不存在----找中间值（通过地板除找到中间索引）----判断再左边还是右边，进行切分----逻辑的重复
nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
def search(search_num,nums):
    print(nums)
    if len(nums) == 0:
        print('not exists')
        return
    mid_index=len(nums) // 2         #通过列表长度地板除，得到中间值的索引
    if search_num > nums[mid_index]:   #
        # in the right
        nums=nums[mid_index+1:]         #列表进行新的切分，切分成一个新的列表
        search(search_num,nums)         #调用自身函数，进行下一层递归
    elif search_num < nums[mid_index]:
        # in the left
        nums=nums[:mid_index]
        search(search_num,nums)
    else:
        print('find it')

search(31,nums)


                                                                 匿名函数

# 有名函数：基于函数名重复使用
# def func():
#     print('from func')

# func()    #基于函数名，进行重复的调用
# func()
# func()


# 匿名函数:没有绑定名字的下场是用一次就回收了
# def func(x,y): #func=函数的内存地址
#     return x + y

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

# f=lambda x,y:x+y      #x,y代表的是匿名函数的参数，x+y相当于有名函数里return后的值。
# print(f)           #匿名函数的内存地址。
# print(f(1,2))     #拿到的是匿名函数的返回值。

#匿名函数一般不单独使用，通常与max min map filter sorted这些函数连用。
#max min map filter sorted

# 举例：求出下列工资最高的人的名字
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

# max的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给key指定的函数,然后将该函数的返回值当作判断依据
# def func(k):
#     return salaries[k]
#
# print(max(salaries,key=func)) #next(iter_s)    #先把salaries转变成迭代器，然后next出来的值赋值给func,比较func的返回值，最后再把值返回出来
#'egon', v1=func('egon')
#'alex', v2=func('alex')
#'wupeiqi', v3=func('wupeiqi')
#'yuanhao', v4=func('yuanhao')



# salaries={
#     'egon':3000,
#     'alex':100000000,
#     'wupeiqi':10000,
#     'yuanhao':2000
# }
# print(max(salaries,key=lambda k:salaries[k])) #next(iter_s)
#先把salaries转变成迭代器，然后next取出每一个值，赋值给后面的匿名函数，冒号后面的是返回值，指定判断依据，最后返回回来不改变max的特性，打印出来的还是key
# print(min(salaries,key=lambda k:salaries[k])) #next(iter_s)


# 先来基本介绍一下sorted函数，sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse这三个参数。
#
# 其中iterable表示可以迭代的对象，例如可以是dict.items()、dict.keys()等，key是一个函数，用来选取参与比较的元素，reverse则是用来指定排序是倒序还是顺序，reverse=true则是倒序，reverse=false时则是顺序，默认时reverse=false。
# l=[10,1,3,-9,22]
# l1=sorted(l,reverse=False)
# print(l1)

# l2=sorted(l,reverse=True)
# print(l2)

# salaries={
#     'egon':3000,
#     'alex':100000000,
#     'wupeiqi':10000,
#     'yuanhao':2000
# }
#
# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

names=['张明言','刘华强','苍井空','alex']

# map的工作原理:  map函数的原型是map(function, iterable, …)这个函数的意思就是将function应用于iterable的每一个元素，结果以列表的形式返回。
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后将该函数的返回值当作map的结果之一
# aaa=map(lambda x:x+"_SB",names)
# print(aaa)
# print(list(aaa))      #返回的是一个列表

# print([name+"_SB" for name in names])

# filter的工作原理
格式：
filter(func, seq)
该函数的目的是提取出seq中能使func为true的元素序列。func函数是一个布尔函数，filter()函数调用这个函数一次作用于seq中的每一个元素，筛选出符合条件的元素，并以列表的形式返回。
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res
names=['alexSB','egon','wxxSB','OLDBOYSB']

# print([name for name in names if name.endswith('SB')])

aaa=filter(lambda x:x.endswith('SB'),names)
print(aaa)
print(list(aaa))