python 内置函数(二) 进阶函数 递归内容及二分法查找 知识点

1,lambda:  匿名函数

2.sorgted()  排序函数

3,filter()  　过滤函数 筛选

4,map() 　映射函数

5.递归

6.二分法

一. 匿名函数: lambda

lambda 表示的是匿名函数,不用def 来声明,一句话就可以声明一个函数.

例如:我们为力了解决一些简单的需求而设计了一句话函数:

def func(n): return n *n     return func() print(ret) #

但是我们用匿名函数就会相对来说方便一些

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

例: 同上 匿名函数的操作方法

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

def func(a,b) return a + b     x = lambda a,b : a + b print(x(1,2)) #

笔试题

def func(x,y)
    return x ,y
print(func(1,2))

 # (1,2)  元组形式

匿名函数方法:
错误(大坑)
a = lambda x,y : 1,2
print(a)
#
(<function <lambda> at 0x0000000000613E18>, 2)  前三项会算到一起

正确的方法:
a = lambda x,y : (1,2)
print(a)
#
(1,2) 元组形式

匿名函数,给函数传递多个参数,返回最大值

func = lambda *ages : max(ages) #单行函数    print(func(1,2,3,4,5,6,66,7,8,99,34,2,32,53,5,256)) # 256

注意;

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

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

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

匿名函数的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的,统一都叫 lambda .在调用的时候没有什么特别之处.

二. sorted() 排序函数

语法: sorted(Iterable,key ,reverse)

iterable:可迭代对象

key;排序规则.

运行流程:sorted函数内部会把可迭代对象中的每一个元素交给后面的key 函数来执行,得到一个数字(权重),通过这个数字进行排序.

reverse: 是否倒序  True;是  False: 否

例: 列表的排序

lis = [1,2,4,55,67,8,9,32,45]

lis.sort()  # 列表的方法

print(lis)

# [1,2,4,8,9,32,45,55,67]

 内置函数提供了一个通用的排序方案, sorted()

s = sorted(lis)

print(lis)

# [1,2,4,8,9,32,45,55,67]

例;  列表

lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]
def func(a):
    return len(a)//2

ll = sorted(lst, key=func)

print(ll)

#
['聊斋', '西游记', '葫芦娃', '水浒传', '年轮', '亮剑', '三国演义']

def func(s):
    return len(s)%2
ll = sorted(lst, key=func)
print(l1)

#
['聊斋', '三国演义', '年轮', '亮剑', '西游记', '葫芦娃', '水浒传']

例:字典   和lambda组合使用

lst = [
    {'name':"汪峰","age":48},
    {"name":"章子怡",'age':38},
    {"name":"alex","age":39},
    {"name":"wusir","age":32},
    {"name":"赵一宁","age":28}
    ]
# 按照名字长度排序
ll = sorted(lst, key=lambda el: len(el['name']), reverse=False)
print(ll)

#结果
[{'name': '汪峰', 'age': 48}, {'name': '章子怡', 'age': 38}, {'name': '赵一宁', 'age': 28}, {'name': 'alex', 'age': 39}, {'name': 'wusir', 'age': 32}]

#按照名字长度排序  倒序
ll = sorted(lst, key=lambda el: len(el['name']), reverse=True)
print(ll)
#结果
[{'name': 'wusir', 'age': 32}, {'name': 'alex', 'age': 39}, {'name': '章子怡', 'age': 38}, {'name': '赵一宁', 'age': 28}, {'name': '汪峰', 'age': 48}]

三.filter() 过滤函数 筛选

语法;  filter(function,iterable)

把可迭代对象中的每一个元素交给前面的函数(function)进行筛选,函数(function)返回 True 或者 False .

所有返回的 True 都会被留下,所有返回的 False 都会被过滤掉.

例:

lst = ["张无忌", "张铁林", "赵一宁", "石可心","马大帅"]
f = filter(lambda el : el[0] != "张",lst)
# 将lst中的每一项传递给func, 所有返回True的都会保留, 所有返回False都会被过滤掉
print("__iter__"in dir(f))  #判断是否可以进行迭代
for e in f:
    print(e)

#
True
赵一宁
石可心
马大帅

例:

lst = [
    {"name":"汪峰", "score":48},
    {"name":"章子怡", "score":39},
    {"name":"赵一宁","score":97},
    {"name":"石可心","score":90}
]

f = filter(lambda el: el['score'] < 60 , lst) # 根据分数低于60分的  去16期的人

print(list(f))

#
[{'name': '汪峰', 'score': 48}, {'name': '章子怡', 'score': 39}]

四.map() 映射函数

语法: map(function,iterable)

把可迭代对象中的数据交给前面的函数进行执行,返回值就是map的处理结果.

例:   计算列表中每个数字的平方

lst = [1,4,7,2,5,8]

lst = [1,4,7,2,5,8]
def func(el):
    return el**2
m = map(func,[1,4,7,2,5,8])
print(lst(m))

#
[1, 16, 49, 4, 25, 64]

#转换成 lambda
m = map(lambda el ; el**2,lst)   #把后面的可迭代对象中的每一个元素传递给function, 结果就是function的返回值print(lst(m))

#
[1, 16, 49, 4, 25, 64]

分而治之 :  map(func1, map(func2, map(func3 , lst)))

例;

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

lst1 = [1, 3, 5, 7,8]

lst2 = [2, 4, 6, 8, 10]

m = map(lambda x,y : x + y ,lst1,lst2)

print(list(m))

# [3, 7, 11, 15, 18]

水桶效应(短板效应), zip()

lst1 = [1, 3, 5, 7]

lst2 = [2, 4, 6, 8, 10]

m = map(lambda x, y, z: x + y+ z, lst1, lst2, [5,1,2,3,6])

print(list(m))

# [8, 8, 13, 18]

五.递归

函数自己调用自己

递归深度. 你可以自己掉用自己的次数.

最大深度: 1000, 到不了1000就停了.

官方文档中递归最大深度是1000. 在这之前就会给你报错

例;

count = 1
def func():
    global count
    print("alex是很帅的", count)
    count = count + 1
    func()
func()

# 
........
alex是很帅的 990
alex是很帅的 991
alex是很帅的 992
alex是很帅的 993
alex是很帅的 994
alex是很帅的 995
alex是很帅的 996
alex是很帅的 997
alex是很帅的 998Traceback (most recent call last):
  File "E:/python_01/day15/code/08 递归.py", line 11, in <module>
    func()
  File "E:/python_01/day15/code/08 递归.py", line 10, in func
    func()
  File "E:/python_01/day15/code/08 递归.py", line 10, in func
    func()
  File "E:/python_01/day15/code/08 递归.py", line 10, in func
    func()
  [Previous line repeated 993 more times]
  File "E:/python_01/day15/code/08 递归.py", line 7, in func
    print("alex是很帅的", count)
RecursionError: maximum recursion depth exceeded while calling a Python object

Process finished with exit code 1

递归的应用:

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

# 遍历 D:/sylar文件夹, 打印出所有的文件和普通文件的文件名
import os
def func(filepath, n): # d:/sylar/
    # 1,打开这个文件夹
    files = os.listdir(filepath)
    # 2. 拿到每一个文件名
    for file in files:  # 文件名
        # 3. 获取到路径
        f_d = os.path.join(filepath, file) # d:/sylar/文件名/
        # 4. 判断是否是文件夹
        if os.path.isdir(f_d):
            # 5. 如果是文件夹. 继续再来一遍
            print("\t"*n, file,":") # 打印文件名
            func(f_d, n + 1)
        else:   #  不是文件夹. 普通文件
            print("\t"*n, file)

func("d:/sylar",0)

六.二分法查找

核心: 掐头去尾取中间. 一次砍一半

两种算法: 常规循环, 递归循环

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

例:  for循环方法查找

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789 ]
n = 79

for el in lst:
    if el == n:
        print("找到了")
        break
else:
    print("没有")

#
没有    

例: 二分法查找; 使用二分法可以提高效率, 前提条件:有序序列    /非递归二分法查找

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
n = 88
left = 0
right = len(lst) - 1
while left <= right:          # 边界, 当右边比左边还小的时候退出循环
    mid = (left + right)//2  ## 必须是整除. 因为索引没有小数
        if lst[mid] > n:
            right = mid - 1
        if lst[mid] < n:
            left = mid + 1
        if lst[mid] ==n:
            print("找到这个数了")
            break
else:
    print("没有这个数")

#
找到这个数了

例: 递归二分法 查找

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
def func(n,left,right):
    if left <= right:
        mid = (left+right)//2
    if n < lst[mid]:
        right = mid -1
        return func(n,left,right)
    if n > lst[mid]:
        left = mid + 1
        return func(n,left,right)
    if n == lst[mid]:
        print("找到这个数了")
        return mid
else:
    print("没有这个数")
    return -1
ret = func(77,0,len(lst) - 1)
print(ret)

#
找到这个数了
6

另类二分法,很难计算位置

def binary_search(ls, target):
 left = 0
 right = len(ls) - 1
 if left > right:
 print("不在这里")
 middle = (left + right) // 2
 if target < ls[middle]:
 return binary_search(ls[:middle], target)
 elif target > ls[middle]:
 return binary_search(ls[middle+1:], target)
 else:
 print("在这里")
binary_search(lst, 567)

最快的查找方法:(面试题)

例:

# 时间复杂度最低, 空间复杂度最低
lst1 = [5,6,7,8]
lst2 = [0,0,0,0,0,1,1,1,1]
for el in lst1:
    lst2[el] = 1

lst2[4] == 1   # o(1)

列表相对字典省空间