内置函数2-匿名函数

  一、lambda匿名函数：（为了解决简单的需求而设计的函数）

　　1、语法：

　　　　　　lambda 参数：返回值

　　　　　　不能完成复杂的操作

　　

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

#匿名函数
f = lambda n:n**n
print(f(10))

lambda表示的是匿名函数，不要需要def来声明，一句话就可以声明一个函数

　　2、注意：

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

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

　　　　返回值和正常的函数一样，可以是任意数据类型

　　3、匿名函数并不是说一定给没有名字，这里前面的变量就是一个函数名，说他是匿名的原因是我们通过__name__查看的时候是没有名字的，统一叫lambda。在调用的时候没有特别之处，像正常的函数调用即可。　　

二、sorted()函数：（排序函数）

　　语法：

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

　　　　lterable:可迭代对象

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

　　　　3、reverse.是否倒序，True：倒序，Fals：正序（默认是正序）

lst = [1,6,7,9,3,0,58,0,14]
lst1 = sorted(lst)
print(lst)   #原来的列表不变
print(lst1)  #返回的新的列表是经过排序的

dic = {1:"A",3:"C",2:"B"}
print(sorted(dic))  #如果是字典，则返回排序的结果是key

@和函数组合使用：

#根据字符串的长度排序
lst = ["张无忌","周芷若","赵敏","金毛狮王"]
#计算字符串长度
def func(s):
    return len(s)
print(sorted(lst,key=func))
#结果：
['赵敏', '张无忌', '周芷若', '金毛狮王']

@和lambda组合使用：

#根据字符串的长度进行排序
lst = ["紫薇","五阿哥","金毛狮王","张无忌"]
#计算字符串的长度
def func(s):
    return len(s)
print(sorted(lst,key=lambda s:len(s)))
#结果：
['紫薇', '五阿哥', '张无忌', '金毛狮王']


lst = [{"id":1,"name":"alex","age":18},
       {"id":2,"name":"紫薇","age":22},
       {"id":3,"name":"五阿哥","age":16}]
#按照年龄进行排序
print(sorted(lst,key=lambda e:e["age"]))
#结果：
[{'id': 3, 'name': '五阿哥', 'age': 16}, {'id': 1, 'name': 'alex', 'age': 18}, {'id': 2, 'name': '紫薇', 'age': 22}]

 

三、filter()函数：（过滤）

　　语法：

　　　　filter(function.lterable)

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

　　　　lterable:可迭代对象

lst = [1,2,3,4,5,6,7,8,9]
ll = filter(lambda x:x % 2 == 0, lst)  #筛选所有的偶数
print(ll)  #打印的是内存地址
print(list(ll))  #打印最终结果
#结果：
<filter object at 0x0000020BA6EC90F0>
[2, 4, 6, 8]


lst = [{"id":1,"name":"alex","age":18},
       {"id":2,"name":"紫薇","age":22},
       {"id":3,"name":"五阿哥","age":16}]
le = filter(lambda e : e ["age"] > 16,lst)  #筛选出年龄大于16岁的数据
print(list(le)) 
#结果：
[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 2, 'name': '紫薇', 'age': 22}]

 

四、map()映射函数

　　语法：

　　　　map(function,iterable) 

　　　　可以对可迭代对象中的每一个元素进行映射，分别去执行function

@计算列表中每一个元素的平放，返回一个新列表

def func(e):
    return e*e
mp = map(func,[1,2,3,4,5])
print(mp)
print(list(mp))
#结果：
<map object at 0x0000020236767940>
[1, 4, 9, 16, 25]

#--------改写成lambda--------------
print(list(map(lambda e : e*e,[1,2,3,4,5])))
#结果：
[1, 4, 9, 16, 25]

@计算两个列表中相同位置的和

lis1 = [1,2,3,4,5]
lis2 = [2,3,4,5,6]
print(list(map(lambda x,y:x+y,lis1,lis2)))
#结果：
[3, 5, 7, 9, 11]

 

五、递归：

　　　1、在函数中调用函数本身，就是递归

　　　　def func():

　　　　　　func()

　　　　func()

def func():
    print("我是张无忌")
    func()
func()

@在python中递归的深度最大到998
def foo(n):
    print(n)
    n +=1
    foo(n)
foo(1)
#计算结果：
...
995
996
997
998Traceback (most recent call last):

@可以调整递归深度
import sys
sys.setrecursionlimit(10000)    # 可以调整递归深度. 但是不一定能跑到这里
def func(count):
    print("我是谁,我在哪里"+str(count))
    func(count+1)
func(1)

　　2、递归的应用：可以使用递归来遍历各种树形结构，比如我们的文件夹，可以使用递归来遍历该文件夹所有的文件。

@遍历树形结构：
import os
filePath = "d:\py\python_tc"  #可根据实际修改路径
def read(filePath,n):
    it = os.listdir(filePath)  #打开文件夹
    for el in it:
#       拿到路径
        fp = os.path.join(filePath,el)  #获取到绝对路径
        if os.path.isdir(fp):  #判断是否是文件夹
            print("\t"*n,el)
            read(fp,n+1)  #又是文件夹，继续读取内部的内容，递归入口
        else:
            print("\t"*n,el)
read(filePath,0)

　　　　难点：不好想，需要找规律，不好读

六、二分法：

　　二分查找每次能够排除掉一半的数据，查找效率非常高，但是局限性比较大，必须是有序序列才可以使用二分查找。（掐头结尾取中间，不停的改变左和右，间接改变中间，查询效率非常高）

#判断n是否在lst中出现，如果出现请返回n所在的位置
#1、二分法查找，----非递归算法
lst = [22,33,44,55,66,77,88,99,102,234,547,5476,78,780]
n = 234
left = 0
rigth = len(lst)-1
count = 1
while left <= rigth:
    middle = (left + rigth) // 2
    if n < lst[middle]:
        rigth = middle -1
    elif n >lst[middle]:
        left = middle + 1
    else:
        print(count)  #查找的次数
        print(middle) #下标位置
        break
    count += 1
else:
    print("这个数不存在！")

#2、普通递归版本二分法：
lst = [22,33,44,55,66,77,88,99,102,234,547,5476,78,780]
def binary_search(n,life,right):
    if life <= right:
        middle = (life + right) // 2
        if n < lst[middle]:
            right = middle - 1
        elif n > lst[middle]:
            life = middle + 1
        else:
            return middle
        return binary_search(n,life,right) #这个return必须加，否则接收到的永远是None
    else:
        return -1
print(binary_search(102,0,len(lst) - 1))

#另类二分法，很难计算位置
lst = [22,33,44,55,66,77,88,99,102,234,547,5476,78,780]
def binary_search(lst,target):
    left = 0
    right = len(lst) - 1
    if left > right:
        print("不再这里。")
    middle = (left - right) // 2
    if target < lst[middle]:
        return binary_search(lst[:middle],target)
    elif target > lst[middle]:
        return binary_search(lst[middle+1 :],target)
    else:
        print("在这里")
binary_search(lst,77)