函数进阶,递归,二分法查找

匿名函数

语法:lambda 参数: 返回值

函数没有具体的名称,统一称为lambda,通常咱们把那个等价的变量当作函数来调用

#求n的平方
a = lambda n : n * n
print(a(9)) # 81



a = lambda x,y : (x,y) # 两个参数以上的须要将返回值划为一个总体,不然会报错
print(a(250,38))# 250,38

repr()

功能:返回一个对象的string形式（原形毕露)

print("你好. 我叫周润发") # 你好. 我叫周润发      对用户是友好的. 非正式的字符串
# 正式(官方)的字符串, 面向对象的时候
print(repr("你好, 我叫周润发")) # '你好, 我叫周润发'
#程序中内部存储的内容, 这个是给程序员看的

print("我叫%r" % "周润发") # %r 实际上调用的是repr()
# 原样输出
# print(r"马化腾说:\"哈哈哈, \" \n\t")# 马化腾说:\"哈哈哈, \" \n\t

print("你好") # 用户看着舒服
print(repr("你好")) # 真实的字符串表示形式(正式的)

sorted()

功能:排序函数

语法:sorted(iterable, key, reverse(默认值是False))

key: 排序规则,排序方案

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

lst = [16, 18, 32, 54, 12, 9]
s = sorted(lst)
print(s) # [9, 12, 16, 18, 32, 54]

#根据元素长度排序
lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]

def func(s):
    return len(s)
ll = sorted(lst,key=func)
print(ll)   #['聊斋', '年轮', '亮剑', '西游记', '葫芦娃', '水浒传', '三国演义'] 


#根据字典中年龄排序
lst = [
    {'name':"汪峰","age":48},
    {"name":"章子怡",'age':38},
    {"name":"alex","age":39},
    {"name":"wusir","age":32},
    {"name":"赵一宁","age":28}
    ]

ll = sorted(lst, key=lambda el: el['age'], reverse=True) #降序
print(ll)
#
[{'name': '汪峰', 'age': 48}, {'name': 'alex', 'age': 39}, {'name': '章子怡', 'age': 38}, {'name': 'wusir', 'age': 32}, {'name': '赵一宁', 'age': 28}]

filter()

功能:过滤,筛选

#去除其中姓张的人
lst = ["张无忌", "张铁林", "林俊杰", "周杰伦","张先生"]
def func(el):
    if el[0] == '张':
        return False # 不想要的
    else:
        return True # 想要的
f = filter(lambda el: el[0]!="张", lst) # 将lst中的每一项传递给func, 全部返回True的都会保留, 全部返回False都会被过滤掉
print("__iter__" in dir(f)) # 判断是否能够进行迭代
for e in f:
    print(e) #    林俊杰
                  # 周杰伦    



lst = [
    {"name":"汪峰", "score":48},
    {"name":"章子怡", "score":39},
    {"name":"周杰伦","score":97},
    {"name":"林俊杰","score":90}
]

f = filter(lambda el: el['score'] < 60 , lst) # 去除低于60的人
print(list(f))   # [{'name': '汪峰', 'score': 48}, {'name': '章子怡', 'score': 39}]

** map()

功能:第一个参数 function 以参数序列中的每个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

语法:map(function, iterable, ...)

• function -- 函数，有两个参数
• iterable -- 一个或多个序列

#计算列表中每一个元素的平方
lst = [1,4,7,2,5,8]
def func(el):
    return el**2
m = map(lambda el: el**2, lst) # 把后面的可迭代对象中的每个元素传递给function, 结果就是function的返回值
print(list(m)) # >>> [1, 16, 49, 4, 25, 64]


#两个列表按位置相加
lst1 = [1, 3, 5, 7]
lst2 = [2, 4, 6, 8, 10]
# 水桶效应 只能取到长度最短的那个
m = map(lambda x, y: x + y, lst1, lst2)
print(list(m)) #>>>[3, 7, 11, 15]
 map思想:
分而治之
语法:map(函数1, map(函数2, map(函数3 , lst)))

** 递归

语法:

def lg():
    lg()
lg()

View Code

通俗来说,就是函数内部本身调用本身,造成一个死循环,不过这个死循环是有限度的,上限是1000次,到不了1000就停了

缘由:使用递归函数须要注意防止栈溢出。在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出

count = 1
def func():
    global count
    print("alex是很帅的", count)
    count = count + 1
    func()
func()
>>>#count 一直到996才停

遍历 D:/sylar文件夹, 打印出全部的文件和普通文件的文件名
import os
def func(filepath, n): # d:/sylar/

    files = os.listdir(filepath) # 1,打开这个文件夹

    for file in files:  # 文件名 # 2. 拿到每个文件名

        f_d = os.path.join(filepath, file) # d:/sylar/文件名/ # 3. 获取到路径 
        
        if os.path.isdir(f_d): # 4. 判断是不是文件夹

            print("\t"*n, file,":") # 打印文件名

             func(f_d, n + 1)  #   5. 若是是文件夹. 继续再来一遍 
 
        else:   #  不是文件夹. 普通文件
             print("\t"*n, file)        

func("d:/sylar",0)

** 二分法查找

核心思想:掐头去尾取中间,一次砍掉一半,大大提升查找效率

由于其前提条件,能够和冒泡排序搭配使用

# 查找一个数n是否在这个序列中,使用二分法能够提升效率, 前提条件:有序序列
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: # 边界
        print("哈哈")
        mid = (left + right)//2
        if n > lst[mid]:
            left = mid + 1
            return func(n, left, right) # 递归  递归的入口
        elif n < lst[mid]:
            right = mid - 1
            # 深坑. 函数的返回值返回给调用者
            return func(n, left, right)    # 递归
        elif n == lst[mid]:
            print("找到了")
            return mid
            # return  # 经过return返回. 终止递归
    else:
        print("没有这个数") # 递归的出口
        return -1 # 1, 索引+ 2, 什么都不返回, None
# 找66, 左边界:0,  右边界是:len(lst) - 1
ret = func(70, 0, len(lst) - 1)
print(ret) # 不是None   前提:必须每层都有一个返回值,若是最后给return,依然是None,
                #由于return返回的值是向上一层返回的