python学习第13天----lambda、sorted、map、filter、递归、二分查找

1.lambda（匿名函数）

1）当需要用到很简单的函数时，可以使用lambda；一行可定义一个函数，但是不能完成复杂的函数操作

2）语法：

         lambda x,y: x+y

lambda后的变量为参数，冒号后面时函数体（直接return的内容）

#普通函数

def func(n):
    return n*n
print(func(3))

#匿名函数

a = lambda n: n*n
print(a)  #直接打印为内存地址
print(a(3))

3)lambda生成的匿名函数，函数名都为lamdba;可以通过函数__name__查看

def func(n):
    return n*n
print(func(3))

a = lambda n: n*n
print(a)  #直接打印为内存地址
print(a(3))

x = func
print(x.__name__)
print(a.__name__)
输出：
9
<function <lambda> at 0x000001C0FFC1B0D0>
9
func
<lambda>

3）lambda(匿名函数)注意事项

①函数的参数可以有多个，多个参数之间只能用逗号隔开

②匿名函数不管有多复杂，只能写一行，且逻辑结束后直接返回数据

③返回值和正常的函数一样，可以是任意的数据类型；若要返回一个列表，可使用推导式

注：匿名函数并不是一定没有名字，前面的变量就是一个函数名；只是通过__name__查看的时候是没有名字的，同意都叫lambda,在调用的时候没有特殊之处，像正常的函数调用即可

2.sorted()内置函数-------用于排序

1）语法

         sorted(lterable，key=None,reverse=False)

         参数说明：

lterable:可迭代对象

key:排序规则（排序函数）,在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数，根据函数运算的结果进行排序

#sort()是列表自身的一个方法，是对自身的一个修改和处理
lst = [2,7,3,8,13,9]
lst.sort()
print(lst)

#sotred()是一个内置函数，返回的是一个新列表，新列表是被排序的
lst = [2,7,3,8,13,9]
lst_new = sorted(lst)
print(lst_new)
输出：
[2, 3, 7, 8, 9, 13]
[13, 9, 8, 7, 3, 2]

#倒叙排列

lst = [2,7,3,8,13,9]
lst_new = sorted(lst,reverse=True)
print(lst_new)
输出：
[13, 9, 8, 7, 3, 2]

#参数key的使用：根据字符串的长度对列表进行排序

lst = ["英雄联盟","飞车","DNF","剑灵","地下城勇士"]
def func(s):
    return len(s)
lst_new = sorted(lst,key = func)  #是把可迭代对象中的每一个元素传递给func
print(lst_new)
输出：
['飞车', '剑灵', 'DNF', '英雄联盟', '地下城勇士']

#lambda配合sorted()一起使用

lst = ["英雄联盟","飞车","DNF","剑灵","地下城勇士"]
lst_new = sorted(lst,key = lambda s: len(s))
print(lst_new)
输出：
['飞车', '剑灵', 'DNF', '英雄联盟', '地下城勇士']

#将列表中的人，按照年龄进行排序

lst = [
    {"id":1,"name":"九尾妖狐","age":26},
    {"id":2,"name":"惩戒之箭","age":28},
    {"id":3,"name":"远古巫灵","age":18}
]
lst_new = sorted(lst,key = lambda dic :dic["age"])
print(lst_new)
输出：
[{'id': 3, 'age': 18, 'name': '远古巫灵'}, {'id': 1, 'age': 26, 'name': '九尾妖狐'}, {'id': 2, 'age': 28, 'name': '惩戒之箭'}]

3.filter()函数------栓选

1）语法

         filter(function,lterable)

         参数说明：

         function:用来筛选的函数，会自动的把iterable中的元素传递给function，然后根据function返回的True或False来判断是否保留次项数据，如果是True则保留下该元素

         lterable:可迭代对象

注：filter的返回结果是一个迭代器

#判断哪些是技术

def func(i):
    return i % 2 == 1
lst= [1,2,3,4,5,6,7,8]
ll = filter(func,lst)
print(ll)
print(list(ll))
输出：
<filter object at 0x000001865882CAC8>
[1, 3, 5, 7]

#通过lambda修改以上程序

lst= [1,2,3,4,5,6,7,8]
ll = filter(lambda i:i%2==1,lst)
print(ll)
print(list(ll))
输出：
<filter object at 0x0000022E8728CAC8>
[1, 3, 5, 7]

#筛选出列表中年龄大于20的元素

lst = [
    {"id":1,"name":"九尾妖狐","age":26},
    {"id":2,"name":"惩戒之箭","age":28},
    {"id":3,"name":"远古巫灵","age":18}
]

lst_new = filter(lambda dic:dic["age"]>20,lst)
print(list(lst_new))
输出：
[{'age': 26, 'name': '九尾妖狐', 'id': 1}, {'age': 28, 'name': '惩戒之箭', 'id': 2}]

4.map()----映射函数

1）语法：

         map(function,iterable)

         可以对可迭代对象中的每一个元素进行映射，分别取执行的function（即把可迭代对性的每一项取出来，执行前面的函数）；返回的也是一个迭代器

#计算列表中每个元素的平方，返回新列表

lst = [1,2,3,4,5,6,7,8,9]
def func(i):
    return i * i
a = map(func,lst)   #相当于把一个大的集合，分开处理，处理完成后再收回
print(list(a))
输出：
[1, 4, 9, 16, 25, 36, 49, 64, 81]

#map()配合lambda表达式

lst = [1,2,3,4,5,6,7,8,9]
a = map(lambda x : x * x ,lst)
print(list(a))
输出：
[1, 4, 9, 16, 25, 36, 49, 64, 81]

#使用lambda时，如果函数中有多个参数，后面对应的别表要一一对应

#将两个列表相加
lst1 = [1,22,53,23,10]
lst2 = [2,10,20,31,11]
print(list(map(lambda x,y:x+y,lst1,lst2)))
输出：
[3, 32, 73, 54, 21]

5.递归（即函数自己调用自己）

因为每次调用函数都会开辟新的内存空间，所以递归函数如果没有次数限制，内存一定会爆，所以在python中有一个最大的内存深度为997

1）可通过sys模块中setrecusionlimit()调整最大递归深度，但是不一定只执行得到

import sys
sys.setrecursionlimit(1000)
def func(count):
   print(str(count))
   func(count + 1)
func(1)

2）递归最大得用处就是遍历树型解构

#通过递归查找文件和文件夹

import  os
filePath = "d:代码python"
def read(filePath, n):
    it = os.listdir(filePath)   # 打开文件夹
    for el in it:
        #  拿到路径
        fp = os.path.join(filePath, el) # 获取到绝对路径
        if os.path.isdir(fp):   # 判断是否是文件夹
            print("	"*n,el)
            read(fp, n+1)    # 又是文件夹. 继续读取内部的内容 递归入口
        else:
            print("	"*n,el)    # 递归出口

read(filePath, 0)

6.二分查找

         每次能够排除掉一半得数据，查找得效率非常高，但是局限性比较大，必须是有序序列才可以使用二分查找

1）二分法查找一个数（不使用递归）

lst = [4,7,10,23,66,136,254,666,728,999]
n = 136
left = 0
right = len(lst)-1
while left<=right:
    middle = (left + right) // 2
    if n<lst[middle]:
        right = middle - 1
    elif n>lst[middle]:
        left = middle + 1
    else:
        print("数字存在，位置为："+str(middle))
        break
else:
    print("数字不存在")
输出：
数字存在，位置为：5

2）通过递归得方式实现（以取列表左右两边值的方式实现）

lst = [4,7,10,23,66,136,254,666,728,999]
def func(left,right,n):
    middle = (left+right)//2
    if n>lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return func(left,right,n)  #如果不返回，第二次调用函数得到得结果接收不到
print(func(0,len(lst)-1,66))
输出：
4

3）通过递归得方式实现（以切列表得方式实现），只能判断数字是否存在于列表中，无法确定在哪

lst = [4,7,10,23,66,136,254,666,728,999]
def func(lst,n):
    left = 0
    right = len(lst) - 1
    middle = (right+left)//2
    if left>right:
        print("找不到")
        return -1
    if n > lst[middle]:
        lst = lst[middle+1:]
    elif n < lst[middle]:
        lst = lst[:middle-1]
    else:
        print("找到了")
        return
    return func(lst,n)
func(lst,66)
输出：
找到了