python记录_day14 内置函数二 迭代 二分法

一、匿名函数

形式：

lambda 形参：返回值

lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数。匿名函数不是说一定没名字，而是他们的名字统一称为“lambda”,可以用__name__查看

注意:

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

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

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

 #计算n的n次方
 f = lambda n : n**n

 print(f(10))

二、sorted

排序函数，形式  sorted(iterable, key=None, reverse = False)

iterrable ：要进行排序的可迭代对象

key：相当于排序规则，在sorted内部会将可迭代对象的每一个元素传递给这个函数，根据函数的运算结果进行排序

reverse： 升序还是降序，False是升序，True是降序

 lst = ["将夜","择天记","斗破苍穹","武动乾坤"]

 s = sorted(lst, key= lambda el : len(el), reverse = False) #按电视剧名的长度排序

 print(s)

三、filter

筛选函数，形式 filter(function , iterable )

function：筛选规则，将iterable的每一个元素传递给这个函数，根据function返回的True或者False来判断是否保留此项数据

llst = ["将夜","择天记","斗破苍穹","武动乾坤"]

s = filter( lambda el : len(el)>3,lst) #按电视剧名的长度排序
for el in s:
    print(el)

结果：
斗破苍穹
武动乾坤

四、map

映射函数 形式 map(function , iterable)

function：映射规则，分别取iterable中的每一个元素，传递给函数执行，得到新的数据

 #列表中每个元素的平方组成新列表
 lst = [2,4,6,8,10]
 num = map(lambda x:x*x,lst)

 for el in num :
     print(el)

五、递归

在函数中调用函数本身，就是递归（自己调用自己）

递归的最大深度是1000，但是一般都取不到

递归关键的是找到递归入口和递归出口

应用：使用递归遍历文件夹系统（递归可以用来遍历各种树形结构）

 def func(path, ceng)
      lst = os.listdir(path) # 打开一个文件夹. 获取到文件夹内的所有内容
      for el in lst: # 当前文件夹内的所有的文件名(包括文件夹名字)
          file_real_path = os.path.join(path, el)  # 拼接文件的真实路径
          # 判断这个路径是文件还是文件夹
          if os.path.isdir(file_real_path):
              # 递归的入口
              print("\t"*ceng, el)
              func(file_real_path，ceng+1) # 重新执行刚才的操作

         else:   # 不是文件夹, 是文件
              # 递归的出口
             print("\t"*ceng, el)

 func("D:/PyCharm/workspace/周作业",0)  #调用函数

六、二分法

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

 #查找列表中是否存在n
 lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

 #普通查找
 def func():
     n =input(">>")
     for el in lst:
         if el == int(n):
             return True
     else:
         return False

 # print(func())

 #判断列表中是否存在n
 #二分查找---非递归
 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 digui(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:
             print("找到了")
             return True
         #digui(n, left, right)
         return digui(n, left, right)   # 不写return，返回值始终为None
     else:
         return -1
 ret = digui(56,0,len(lst)-1)
 print(ret)

 #二分查找 ----递归（切列表）
 def binary_search(lst,n):
     left = 0
     right = len(lst)-1
     if left >right:
         print("找不到")
     mid = (left + right)//2
     if n < lst[mid]:
         #binary_search(lst[:mid], n)
         return binary_search(lst[:mid],n)  # 不写return，返回值会始终为None
     elif n > lst[mid]:
         #binary_search(lst[mid + 1:], n)
         return binary_search(lst[mid+1: ],n)
     else:
         print("找到了")
         return True
 ret = binary_search(lst,56)
 print(ret)

示例