内置函数2

一. lamda匿名函数

计算n的平方
def func(n):
    return n*n
print(func(3))

9

a=lambda n : n*n
print(a(3))
9

a=lambda x : x*x
print(a)
print(a.__name__)

<function <lambda> at 0x000001EB533FD1E0>

<lambda>       # 查看函数的函数名

b=lambda x,y:x+y
print(b(1,5))
6

一行搞定一个函数. 但是, 不能完成复杂的函数操作

语法:    
函数名 = lambda 参数: 返回值

注意:

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

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

3. 返回值和正常的函数一样, 可以是任意数据类型
匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统⼀一都叫lambda. 在调用的时候没有什么特别之处. 像正常的函数调用即可

二. sorted()    排序函数.

语法: sorted(Iterable, key=None, reverse=False)       

Iterable: 可迭代对象       

key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序

lst=[1,2,7,6,52,4,9]
lst.sort()
print(lst)

lst=[3,2,8,5,45,9,6]
sorted(lst)
print(lst)


lst=[3,2,8,5,45,9,6]
s=sorted(lst)
print(s)

[1, 2, 4, 6, 7, 9, 52]
[3, 2, 8, 5, 45, 9, 6]
[2, 3, 5, 6, 8, 9, 45]

lst=["无双剑姬","蛮王","大保健","诺克萨斯","易大师"]
def func(lst):
    return len(lst)
s=sorted(lst,key=func)
print(s)

s=sorted(lst,key=lambda lst:len(lst))
print(s)

['蛮王', '大保健', '易大师', '无双剑姬', '诺克萨斯']
['蛮王', '大保健', '易大师', '无双剑姬', '诺克萨斯']

lst=["无双剑姬aaa","蛮王aa","大保健aaaaaa","诺克萨斯a","易大师aaaa"]
def func(lst):
    return lst.count("a")
li=sorted(lst,key=func)
print(li)

li=sorted(lst,key=lambda lst:lst.count("a"))
print(li)

['诺克萨斯a', '蛮王aa', '无双剑姬aaa', '易大师aaaa', '大保健aaaaaa']
['诺克萨斯a', '蛮王aa', '无双剑姬aaa', '易大师aaaa', '大保健aaaaaa']

lst=[{"id":1,"name":"宋江","age":28},
     {"id":2,"name":"李逵","age":56},
     {"id":3,"name":"林冲","age":29},
     {"id":4,"name":"花荣","age":18},
     {"id":5,"name":"武松","age":30}]
def func(dic):
    return dic["age"]
print(sorted(lst,key=func))
print(sorted(lst,key=lambda dic:dic["age"]))
[{'id': 4, 'name': '花荣', 'age': 18}, {'id': 1, 'name': '宋江', 'age': 28}, {'id': 3, 'name': '林冲', 'age': 29}, {'id': 5, 'name': '武松', 'age': 30}, {'id': 2, 'name': '李逵', 'age': 56}]
[{'id': 4, 'name': '花荣', 'age': 18}, {'id': 1, 'name': '宋江', 'age': 28}, {'id': 3, 'name': '林冲', 'age': 29}, {'id': 5, 'name': '武松', 'age': 30}, {'id': 2, 'name': '李逵', 'age': 56}]

三. filter()    筛选函数   

语法: filter(function. Iterable)       

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

Iterable: 可迭代对象

lst=[1,2,3,4,5,6,7,8,9]
def func(i):
    return i%2==1
s=filter(func,lst)
print(s)
<filter object at 0x0000023C1AD15EB8>

lst=[1,2,3,4,5,6,7,8,9]
def func(i):
    return i%2==1
s=filter(func,lst)
print(list(s))
[1, 3, 5, 7, 9]

lst=[1,2,3,4,5,6,7,8,9]
s=filter(lambda i :i%2==1,lst)
print(list(filter(lambda i :i%2==1,lst)))
[1, 3, 5, 7, 9]

lst=[{"id":1,"name":"宋江","age":28},
     {"id":2,"name":"李逵","age":56},
     {"id":3,"name":"林冲","age":29},
     {"id":4,"name":"花荣","age":18},
     {"id":5,"name":"武松","age":30}
     ]
s=filter(lambda dic: dic["age"]>40,lst)
print(list(s))
[{'id': 2, 'name': '李逵', 'age': 56}]

四. map()    映射函数   

语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别取执行 function

lst=[1,2,5,6,4,8,24,5,23,25,29,51,12,14]
def func(i):
    return i*i
s=map(func,lst)
print(list(s))

lst=[1,2,5,6,4,8,24,5,23,25,29,51,12,14]
print(list(map(lambda i:i*i,lst)))

[1, 4, 25, 36, 16, 64, 576, 25, 529, 625, 841, 2601, 144, 196]
[1, 4, 25, 36, 16, 64, 576, 25, 529, 625, 841, 2601, 144, 196]

lst1=[1,5,8,9,7]
lst2=[5,9,8,6,4]
print(list(map(lambda x,y:x+y,lst1,lst2)))
[6, 14, 16, 15, 11]

五. 递归   

在函数中调用函数本身. 就是递归

def func():
    print("我喜欢")
    func()
func()

  在python中递归的深度最大到998

import sys
sys.setrecursionlimit(10000)   # 可以调整递归深度. 但是不一定能跑到这里
def func():
    print("我喜欢")
    func()
func()

import sys
sys.setrecursionlimit(10000)   
def func(count):
    print("我喜欢%s" % count)
    func(count+1)
func(1)

递归的应用:    

我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该
文件夹中的所有文件

import  os
filePath="E:chenwei"
def read(filePath,n):
    it=os.listdir(filePath)
    # print(it.__iter__())
    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,1)

# 遍历树形结构
import  os
# filePath="E:chenwei"
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)

六. 二分查找   

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

要求: 查找的序列必须是有序序列.

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
    middle = (left + right) // 2
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        print(count)
        print("存在")
        print(middle)
        break
    count = count + 1
else:
    print("不存在")
4
存在
13

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
def binary_search(left, right, n):
    middle = (left + right)//2
    if left > right:
        return -1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return binary_search(left, right, n)
print(binary_search(0, len(lst)-1, 66) )

5

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
def binary_search(lst, n):
    left = 0
    right = len(lst) - 1
    middle = (left + right) // 2
    if right <= 0:
        print("没找到")
        return
    if n > lst[middle]:
        lst = lst[middle+1:]
    elif n < lst[middle]:
        lst = lst[:middle]
    else:
        print("找到了")
        return
    binary_search(lst, n)
binary_search(lst, 65)

没找到