匿名函数，内置函数，递归函数及二分法

一.什么是匿名函数

    def 定义的是有名函数：特点是可以通过名字重复调用

     def func():

           pass

      匿名函数就是没有名字的函数:特点是只能在定义的时使用一次

二.为何要用匿名函数

    强调：匿名函数的定义就相当于只产生一个变量的值，而没有绑定任何名字，所以会在定义完后就会被回收，无法重复使用，只能在定义时使用一次

    应用：当某一个功能仅使用一次就没有再重复使用的必要了，就因该定义成匿名函数

三.如何使用匿名函数（内置函数+匿名函数）

    lambda x,y:x+y

#===========================================================================
# salaries={
#     "egon":3000,
#     "alex":10000000,
#     "petrus":1000,
#     "kevin":2000
# }

#max函数的用法
#max(*args, key=None) key=函数的内存地址；作用是控制max函数的比较的值
# nums=[10,-1,11,9,23]
# print(max(nums))
# print(max(salaries.values()))  #只能返回最大值


#匿名函数与内置函数的结合使用求出字典里面的最大值的人名
# def func(k):
#     return salaries[k]

#print(max(salaries,key=func))
#1.将可迭代的对象salaries变成迭代器对象iter_obj
#2.next(iter_obj)得到一个人名，然后将该人名当做参数传给key指定的函数，然后调用函数将函数的返回值当做比较依据
#3.比较大小，取出最大值对应的人名
# print(max(salaries,key=lambda k:salaries[k]))
# print(min(salaries,key=lambda k:salaries[k]))
#==============================================================================

#sorted排序的用法
#sorted() 函数对所有可迭代的对象进行排序操作
#sort 与 sorted 区别：
#1.sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
#2.list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
#sorted(iterable[, cmp[, key[, reverse]]])
# iterable -- 可迭代对象。
# cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
# nums=[10,-1,11,9,23]
# print(sorted(nums))
# print(nums)
# print(sorted(salaries,key=lambda k:salaries[k]))
# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))
#===============================================================================

#map的用法
# map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
#map(function, iterable, ...)
#参数
# function -- 函数
# iterable -- 一个或多个序列
#返回值
# Python 2.x 返回列表
# Python 3.x 返回迭代器
# names=["alex","egon","petrus","kevin"]

#方式一：手动实现
# new_names=[]
# for name in names:
#     new_names.append(name+"_dsb")
# print(new_names)

#方式二:列表生成式
# new_names=[name+"_dsb" for name in names]
# print(new_names)

#方式三:map+匿名函数
# res=map(lambda x:x+"_dsb",names)
# # print(list(res))
# print(next(res))
#================================================================================

#reduce的用法
# reduce() 函数会对参数序列中元素进行累积。
# 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
#reduce(function, iterable[, initializer])
#参数
# function -- 函数，有两个参数
# iterable -- 可迭代对象
# initializer -- 可选，初始参数
#返回值
#返回函数计算结果


#方式一：手动实现
# res=0
# for i in range(101):
#     res+=i
# print(res)

#方式二:列表生成式
# print(sum(i for i in range(101)))

#方式三;reduce+匿名函数
# from functools import reduce
# print(reduce(lambda x,y:x+y,[i for i in range(101)]))
# print(reduce(lambda x,y:x+y,["h","e","l","l","o"],"---------------"))
# print(reduce(lambda x,y:x+y,[i for i in range(101)],100)) #100为reduce函数里面的初始值，可选
#================================================================================================

#filter的用法
# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
#filter(function, iterable)
# function -- 判断函数。
# iterable -- 可迭代对象。
# 返回值
#Pyhton2.7 返回列表，
#Python3.x 返回迭代器对象

# names=["alex_dsb","egon_dsb","kevin_dsb","petrus"]

#方式一：手动实现
# new_names=[]
# for name in names:
#     if name.endswith("sb"):
#         new_names.append(name)
# print(new_names)

# 方式二:列表生成式
# new_names=[name for name in names if name.endswith("sb")]
# print(new_names)

# 方式三:filter+匿名函数
# res=filter(lambda name:name.endswith("sb"),names)
# print(res)
# print(list(res))

四.什么是递归函数

    1.函数的递归调用的是函数嵌套调用的一种特殊形式

    2.特殊之处在调用一个函数的过程中又直接或者间接地调用了该函数的本身

   3.调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其       无    限制占用内存，对函数的递归调用做了最大的层级限制

   4.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个       函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多        会 导致栈溢出）

   4.递归的本质就是一个循环的过程

     但是递归必须满足两个原则：

      1.每进入下一层递归，问题的规模必须有所减少

      2.递归必须有一个明确的结束条件或者说有一个明确的进入下一层递归的条件

    并且递归有两个明确的阶段

       1.回溯：一层一层地递归调用下去

       2.递推：再某一层结束掉递归，然后一层一层返回

五.为何要用递归：

     在某些情况下，基于递归来使用重复的过程比while循环更加简单

六.如何使用

salary(5)=salary(4)+300
salary(4)=salary(3)+300
salary(3)=salary(2)+300
salary(2)=salary(1)+300
salary(1)=100


salary(n)=salary(n-1)+300 n>1
salary(1)=100  n=1


def salary(n):
    if n==1:
        return 100
    return salary(n-1)+300

print(salary(5))

 七.二分法：二分法是算法的一种,算法是如何高效地解决问题的思路

nums = [1, 13, 15, 23, 27, 31, 33, 57, 73, 81, 93, 94, 97, 101]

def binary_search(find_num, nums):
    # print(len(nums))
    if len(nums)==0:
        print("not exist")
        return
    
    mid_index = len(nums) // 2
    if find_num > nums[mid_index]:
        # nums=
        nums = nums[mid_index + 1:]  # 73,81,93,94,97,101
        binary_search(find_num,nums)
    
    elif find_num < nums[mid_index]:
        
            nums = nums[:mid_index]  # 1, 13, 15, 23, 27, 31, 33
            binary_search(find_num, nums)
    else:
        print("find it")

binary_search(97, nums)