内置函数(二)

本节主要内容

1. lamda匿名函数

2. sorted()

3. filter()

4. map()

5 .递归函数

6. 二分查找

一.lamda匿名函数:

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

注意:

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

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

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

# 计算n的n次⽅
def func(n):
 return n**n
print(func(10))

a = func
print(a.__name__)    # 查看函数的函数名:func
# 用以没办法知道函数名字的时候


f = lambda n: n**n  # 一行搞定一个函数. 但是, 不能完成复杂的函数操作
print(f(10))
print(f.__name__))   # <lambda>


a = lambda x,y:x**y    
print(a(10,10))
print(a.__name__))   # <lambda>

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

二.sorted()

排序函数.

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

Iterable: 可迭代对象

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

reverse: 是否是倒序. True: 倒序, False: 正序

lst = [1,5,3,4,6]
lst2 = sorted(lst, key=None, reverse=False)

print(lst) # 原列表不会改变
print(lst2) # 返回的新列表是经过排序的


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':'钢铁侠','age':33},
    {'id':2,'name':'蜘蛛侠','age':22},
    {'id':3,'name':'蝙蝠侠','age':11},
    {'id':4,'name':'煎饼侠','age':55},
    {'id':5,'name':'机器猫','age':44}
]
# 根据年龄进行排序
li = sorted(lst ,key=lambda dic :dic['age'])
print(li)

三. filter()

 筛选函数:

语法: filter(function. Iterable)

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

Iterable: 可迭代对象

 

lst = [1,2,3,4,5,6,7,8,9,]
# 筛选列表中所有的奇数
li = filter(lambda i: i%2==1,lst)
# 第一个参数.函数.将第二个参数中的每一个元素传给函数.函数如果返回True,留下该元素

print(list(li))
==========================

lst = [
    {'id':1,'name':'钢铁侠','age':33},
    {'id':2,'name':'蜘蛛侠','age':22},
    {'id':3,'name':'蝙蝠侠','age':11},
    {'id':4,'name':'煎饼侠','age':55},
    {'id':5,'name':'机器猫','age':44}
]

# 筛选年龄大于40的
li = filter(lambda lst:lst['age']>40,lst)
print(list(li))

 四. map()

映射函数

语法: map(function, iterable)

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

lst = [1,2,3,4,5,6,7,8,9,]
# 求列表中每个元素的平方
it =map(lambda i :i*i,lst)   #  # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器

print(list(it))
===================================

lst = [1,2,3,4,5,6,7,8,9,]
lst1 = [11,22,33,44,55,66,77,88,99,]
# 计算两个列表中相同位置的数据的和

print(list(map(lambda x,y:x+y, lst,lst1)))   #   # 如果函数中有多个参数. 后面对应的列表要一一对应

 五. 递归

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

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

func(1)

递归的应用:  (遍历树形结构)

import  os
filePath = "D:S14即S15 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)

六. 二分查找法

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

# 判断n是否在lst中出现. 如果出现请返回n所在的位置
# 二分查找---非递归算法

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('查找了%s次'% count)
        print("存在")
        print('在索引%s位置'% middle)
        break
    count = count + 1
else:
    print("不存在")

# 普通递归版本二分法

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, 567) )