匿名函数+函数递归+二分法+面向过程编程

# 匿名函数
# 什么是匿名函数？

# 这叫一个有名函数
# def func():
#     print('123')
# 可以通过名字找到值（函数的内存地址），加括号可以重复调用
# func()
# func()
# func()

# 匿名函数：就是没有名字的函数，只能使用一次就被回收
#  定义： lambda 参数：函数体（相当于return结果）
# 调用:  (lambda x,y:x+y)(10,20)
# 会有一个返回值  res= (lambda x,y:x+y)(10,20)
#                 print(res)
# 但是匿名函数不是这么用的，都是跟其他函数结合到一起用，而且只用一次就结束了，不重复用
# 与max，min，sorted,map,reduce,filter等混合使用

# 与max混用
# 要求拿到薪资最多的那个人的姓名
# salaries={
#     'egon':3000,
#     'alex':100000000,
#     'wupeiqi':10000,
#     'yuanhao':2000
# }

# res=max(salaries,key=lambda k:salaries[k])
# print(res)

# max(,key=)工作原理
# 1.首先将可迭代对象变成迭代器对象
# 2.next(迭代器对象)，会有一个返回值，将这个返回值当做参数传给key指定的函数
# 然后将该函数的返回值当做判断的依据
# 3.比较大小取出最大值的人名

# def func(k):
#     return salaries[k]
# print(max(salaries,key=func))

# 与sorted混用,排序
# li=[2,1,45,7,-3]
# print(sorted(li))

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

# 与map混用
# 1.map()（函数，可迭代对象）会将可迭代对象变成迭代器对象
# 2.next()迭代器对象会得到一个返回值，
# 然后将该返回值当做参数传给第一个参数指定的函数
# 然后将函数的返回值当做map的结果之一

# names=['alex','egon','hulaoshi','kevin']
# # 要求所有人名加'sb'结尾
# res=map(lambda name:name+'sb' ,names)
# print(list(res))

# filter()过滤
# names=['alexSB','egon','hulaoshiSB','kevinSB']
# # 要求把带SB的过滤出来
# res=filter(lambda name:name.endswith('SB'),names)
# print(list(res))

# 函数递归
# 1.什么是函数递归调用？
# 在调用一个函数的过程中，有直接或间接地调用了该函数本身
# 是一种特殊的嵌套调用
# import sys
# print(sys.getrecursionlimit())

# def foo(n):
#     print('from foo',n)
#     foo(n+1)
# foo(0)
#直接调用自己

# def bar():
#     print('from bar')
#     foo()
#
# def foo():
#     print('from foo')
#     bar()#print('from bar')
#          # foo()
# foo()
# # 间接调用：先调用foo，调用bar，bar又间接地调用foo
#

# 递归必须有两个明确的阶段：
#     递推：一层一层的递归调用下去,但强调每进入下一层递归，每一次问题的规模都越来越小

#     回溯：递归必须有一个明确的结束条件，在满足该条件是结束递推
#           开始一层一层回溯

# 递归的精髓在于通过不断的重复逼近一个最终的结果（比如问一个人年龄的例子）

# age(5)=age(4)+2
# age(4)=age(3)+2
# age(3)=age(2)+2
# age(2)=age(1)+2
# age(1)=18
def age(n):
    if n == 1:
        return 18
    return age(n-1) + 2
print(age(5))

# 函数递归是一个循环的过程，但是递归必须遵循两个明确的条件：
# a.递归必须有一个明确的结束条件或者有一个明确进入下一层递归的条件

# 为什么要用递归？


# 如何用递归？

# li=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
# # 要求把列表里所有的元素都取出来
# def func(li):
#     for item in li:
#         if type(item) is list:
#             # 继续下一次递归
#             func(item)
#         else:
#             print(item)
# func(li)

# 二分法

# nums=[1,2,10,30,33,99,101,200,301,402]

# print(nums[mid_index])
# print(len(nums))
# 从小到大排列的整形数字列表
# 判断一个整数在不在这个列表里
# num=101
# def find(num,nums):
#     print(nums)
#     if num not in nums:
#         print('不存在')
#         return
#     mid_index=len(nums)//2
#     if num>nums[mid_index]:
#         new_nums=nums[mid_index+1:]
#         find(num,new_nums)
#     elif num<nums[mid_index]:
#         new_nums=nums[:mid_index]
#         find(num,new_nums)
#     else:
#         print('找到了')
#
# find(101,nums)