Day14--Python--函数二,lambda,sorted,filter,map,递归,二分法

今日主要内容:
1. lambda 匿名函数
    lambda 参数: 返回值
-------------------------------------
def square(x):
    return x**2

ret = square
print(ret)
-------------------------------------
zrf = lambda x : x**2  #匿名函数 lambda 参数: 返回值
print(zrf)
ret = zrf(10)
print(ret)

-------------------------------------
#给函数传递两个参数a,b 返回a+b的结果
s = lambda a, b: a + b

ret = s(3, 7)
print(ret)

----------------难题---------------------

def add(a, b):
    return a + b
def test():
    for r_i in range(4):
        yield r_i
g = test()
for n in [3, 8]:
    g = (add(n, i) for i in g) #在未被调用时只记录公式,被调用时套入公式, g = 8
n = 6
print(list(g))

def num():
    return [lambda x: x + i for i in range(4)]   #闭包. i在循环中没被调用,只记录公式,当函数调用时,i=3,x+i 共循环4次,所有公式中i都等于3

print([i(2) for i in num()])

2. sorted 排序
    sorted(Iterable, key=None, reverse=False) #可迭代对象后面两个默认值
    sorted(可迭代对象,key=函数,是否倒序)
    sorted流程:把可迭代对象的每一个元素传递给函数,函数返回一个数字,根据数字进行排序
-------------------------------------
    lst = [1, 2, 22. 5, 10, 92, 88]
    lst2 = sorted(lst) #排序功能
    lst3 = sorted(lst, reverse=True)
    print(lst2)
-------------------------------------
    lst = ['王昭君', '李白', '司马懿', '大乔', '诸葛亮', '周瑜']
    def func(name):
        return len(name)

     l1 = sorted(lst, key=func)
     print(l1)

     a = lambda name: len(name)
     l1 = sorted(lst, key=a)
     print(l1)

     l1 = sorted(lst,key=lambda name: len(name))
     print(l1)
-------------------------------------
lst = [{"id": 1, "name": 'alex', "age": 18},
    {"id": 2, "name": 'wusir', "age": 16},
    {"id": 3, "name": 'taibai', "age": 17}]
# 按照年龄对学⽣信息进⾏排序
# def func(info):
    return info["age"]

# l1 = sorted(lst, key=func)
# print(l1)
l1 = sorted(lst, key= lambda info: info['age'])
print(l1)
-------------------------------------
#按照姓名首字母排序
lst = [{"id": 1, "name": 'alex', "age": 18},
    {"id": 2, "name": 'wusir', "age": 16},
    {"id": 3, "name": 'taibai', "age": 17}]

l2 = sorted(lst, key=lambda dic: ascii(dic['name'][0]))
print(l2)

l3 = sorted(lst, key=lambda dic: ord(dic['name'][0]))
print(l3)

-------------------------------------
3. filter 筛选
    filter(函数,可迭代对象)
    执行流程:
            把可迭代对象中的每一个元素拿出来, 放到func中运行.返回True/False. 根据返回的True和False来决定这个数据是否保留
    #保留列表中大于18的数
    lst = [22, 25, 12, 16, 28]
    f = filter(lambda age: age > 18, lst)
    for el in f:
        print(el)
    print(list(f))
    print(sorted(f))  #对结果排序

    #筛选年龄大于18且为偶数的年龄
    lst = [23, 28, 16, 17, 22, 24]
    f = filter(lambda age: age > 18 and age % 2 == 0, lst)  # f是可迭代对象
    print(list(f))
    f2 = filter(lambda age: age % 2 == 0, filter(lambda age: age>18, lst))
    print(list(f2))
-------------------------------------
    #筛选年龄大于18且为偶数,并排序
    lst = [22, 25, 12, 16, 28]
    print(list(sorted(filter(lambda age: age % 2 == 0,filter(lambda age: age > 18, lst)))))
4. map 映射
    map(函数,可迭代对象)  #结构和filter一样,但可以返回值
    执行流程:
            把可迭代对象中的每一个元素拿出来, 放到func中运行.返回数据就是结果
    lst = [2, 3, 7]
    m = map(lambda x: x**2, lst)
    print(list(m))
--------------------------------
    #求lst1 和lst2中相同索引的数字和组成的列表
    lst1 = [1, 2, 3, 4, 5]
    lst2 = [2, 3, 4, 5, 6]
    print(list(map(lambda x, y: x + y,lst1, lst2)))

5. 递归(难点)
    优点:简单易写,用于遍历树形结构
    缺点:资源消耗大,效率低,需要不停调用函数,开辟空间

    自己调用自己
    递归的入口
    递归的出口: return
    递归的循环条件：动
    循环树形结构:

    def func():
        print('你好啊')
        func()   #递归的入口

    func()  #调用函数
 -----------------------------------
 # 用递归实现1-100:
    def func(index):
        print(index)
        if index == 100: return
        func(index + 1)

    func(1)
     -----------------------------------
    def func(index):
        print(index)  #占用1个空间
        func(index + 1)

    func(1)  #占用1个空间
    #递归深度1000,但是实际到不了1000, 在997-998之间
  -----------------------------------
    import sys
    sys.setrecursionlimit(5000)  #设置递归的最大深度,一般不要改
    def func(index):
        print(index)  #占用1个空间
        func(index + 1)

    func(1)  #占用1个空间

打印路径下所有文件名:

打印路径下的所有文件名
import os
def func(file_path, layer):
    lst = os.listdir(file_path)
    for file in lst:
        full_path = os.path.join(file_path, file)
        if os.path.isdir(full_path):
            print('\t'*layer, file)
            func(full_path, layer + 1)
        else:
            print('\t'*layer, file)
    else:
        return
func('D:\python_work', 0)

6. 二分法查找

    优点:查找效率高
    缺点:必须是有序序列

用二分法判断数字是否在列表中:

#判断输入的数字是否在列表中
lst = [1, 8, 16, 32, 55, 78, 425, 21, 5, 52, 11]
lst = sorted(lst)     #必须是有序数列
n = int(input('请输入一个数:'))
left = 0
right = len(lst) - 1

while left <= right:
    mid = (left + right) // 2   #索引只能是整数
    if n > lst[mid]:
        left = mid + 1
    elif n < lst[mid]:
        right = mid - 1
    else:
        print('在列表中,位置是%s' % mid)
        break
else:
    print('这个数不在此列表中')

用递归法查找数字是否在列表中,方法一:

def func(n, lst):
    left = 0
    right = len(lst) - 1
    if left <= right:
        mid = (left + right) // 2
        if n < lst[mid]:
            new_list = lst[:mid]
            return func(n, new_list)
        elif n > lst[mid]:
            new_list = lst[mid + 1:]
            return func(n, new_list)
        else:
            print('在列表中')
            return True
    else:
        print('不在列表中')
        return False

lst = [1, 8, 16, 32, 55, 78, 425, 21, 5, 52, 11]
lst = sorted(lst)
ret = func(8, lst)
print(ret)

用递归法判断数字是否在列表中,方法二:

def func(n, lst, left=0, right=None):
    if right == None:
        right = len(lst) - 1
    if left <= right:
        mid = (left + right) //2
        if n < lst[mid]:
            right = mid - 1
        elif n > lst[mid]:
            left = mid + 1
        else:
            return True
        return func(n, lst, left, right)
    else:
        return False

lst = [1, 1, 1, 1, 2, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 7, 8, 8, 9, 16, 32, 44, 55, 78, 89]
ret = func(0,lst)
print(ret)