python学习 day014打卡 内置函数二&递归函数

本节主要内容:

1.lambda匿名函数

2.sorted()

3.filter()

4.map()

5.递归函数

6.二分法

一.lambda匿名函数

为了解决一些简单的需求而设计的一句话函数

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

f = lambda n: n**n 
print(f(10))

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

语法:

函数名 = lambda 参数 : 返回值

注意:

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

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

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

匿名函数并不是说一定没有名字.这里前面的变量就是一个函数名.说它是匿名的原因是我们通过__name__

查看的时候是没有名字的,统一叫lambda.在调用的时候没有什么特别之处.像正常的函数调用即可.

二.sorted()

排序函数

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

Iterable:可迭代对象

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

reverse:是否倒叙.Ture:倒叙,False:正序

lst = [1, 5, 3, 4, 6]
lst2 = sorted(lst)
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=[{'id':3,'name':'taihei','age':18},
     {'id':1,'name':'alex','age':28},
{'id':2,'name':'taibai','age':58},

{'id':4,'name':'henhei','age':38}]

# 根据年龄排序
def func(s):
    return s['age']

print(sorted(lst, key=lambda dic:dic["age"]))

三.filter()

筛选函数

语法: filter(function,Iterable)

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

Iterable:可迭代对象

lst = ["渴望", "年轮", "家有儿女", "蜗居", "49天", "浪漫满屋"]

#  把后面的可迭代对象中的每一个元素交给前面的函数。 根据函数返回的True或者False。 判断是否保留该元素
f = filter(lambda s: len(s) > 2, lst)
print("__iter__" in dir(f))
for el in f:
    print(el)


lst=[{'id':3,'name':'taihei','age':18},
     {'id':1,'name':'alex','age':28},
     {'id':2,'name':'taibai','age':58},
     {'id':4,'name':'henhei','age':38}]

# 筛选年龄大于等于38的人
print(list(filter(lambda ren: ren['age']>=38, lst)))

四.map()

映射函数

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

 lst = [2, 3, 4,5, 6, 7, 1]
# 计算列表中的每一项的平方

# 映射
# 把可迭代对象中的每一个元素拿出来交给前面的函数执行. 保留最后的执行结果
m = map(lambda x: x*x, lst)
for el in m:
    print(el)

# 给出一个列表
lst = ["alex_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]
#
# 正确的用户名: alex
# 密码:456
# alex_456
print(list(map(lambda s : " yes" if s=="alex_456" else "false"  , lst)))

print(list(map(lambda s: s.split("_")[0] == 'alex' and s.split("_")[1] == "456",lst)))

五.递归

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

def func():    
    print("我是谁")    
    func() 
func()

在python中递归的深度最大是1000,但是到不了1000,一般是998

def foo(n):    
    print(n)    
    n += 1    
    foo(n) 
foo(1)

 递归的应用:

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

import os

def read(filepath,n):
    files = os.listdir(filepath)    # 获取到当前文件夹中的所有文件
    for fi in files:    # 遍历文件夹中的文件,这里获取的只是本层文件名
        fi_d = os.path.join(filepath,fi)    # 加入文件夹 获取文件夹+文件
        if os.path.isdir(fi_d): #如果该路径下的文件是文件夹
            print("	"*n,fi)
            read(fi_d,n+1)  #继续进行相同的操作
        else:
            print("	"*n,fi)    #递归出口.最终在这里隐含着return

# 递归遍历目录文件下的所有文件
read("d:/python课件及作业",0)
    

六.二分查找

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

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

# 判断n是否在lst中出现.
# 二分查找---非递归算法
lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
n = int(input("请输入一个数字:"))
left = 0
right = len(lst)-1
while left <= right :
    mid = (left + right) // 2
    if n < lst[mid] :
        right = mid - 1
    elif n > lst[mid] :
        left = mid + 1
    else :
        print("找到了")
        break
else:
    print("没找到")

# 普通递归版二分法:
def binary_search(lst,n,left,right):
    if left <= right:
        mid = (left+right)//2
        if n < lst[mid]:
            right = mid - 1
        elif n > lst[mid]:
            left = mid + 1
        else:
            return mid
        return binary_search(lst,n,left,right)    # 这个return必须要加.否则接收到的永远是None
    else:
        return -1


lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
n = int(input("请输入一个数字:"))
left = 0
right = len(lst)-1
print(binary_search(lst,n,left,right))

# 另类二分法,很难计算位置.
def binary_search(lst,n):
    left = 0
    right = len(lst) - 1
    if left > right:
        print("不在这里")
        return False
    mid = (left+right) // 2
    if n < lst[mid]:
        return binary_search(lst[:mid],n)
    elif n > lst[mid]:
        return binary_search(lst[mid+1:], n)
    else:
        print("在这里")
        return True


lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
n = int(input("请输入一个数字:"))
print(binary_search(lst,n))