day15 python
一.匿名函数 lambda
1.lambda函数
def func(n): #普通函数, 功能比较简单, 当函数多的时候, 起名也不好取
return n*n
print(func(9))
a = lambda n : n*n #匿名函数语法: lambda 参数: 返回值
print(a(9))
print(func.__name__) #func
print(a.__name__) #<lambda>匿名函数的名字都是<lambda>, 可以把a认为是函数的名字
a = 1,2,3 #(1,2,3) a是一个元组
a = (1,2,3,) #(1,2,3) a是一个元组
a = (1,2,3) #(1,2,3) a是一个元组
y = 'other'
a = lambda x, y : x, y #(<function <lambda> at 0x0000011A5A332EA0>, 'other') #这时候a是个元组
print(a)
a = lambda x, y : (x, y) #这时的a才是lambda函数, 想要返回多个值, 返回值要加括号
print(a)
2.lambda函数的特点
1.函数的参数可以后多个, 以,号分隔
2.匿名函数不管多复杂只能写一行, 且逻辑结束后返回数据(复杂的用def)
3.返回值和正常的函数一样, 可以是任意数据类型
3.lambda函数练习
a = lambda *args: max(args)
print(a(12,3243,5,3,3))
二.递归(recursion)
函数自己调用自己, 递归默认是死循环
多用于处理类似的算法
函数调用递归过程必须解决两个问题:
一是递归计算的公式
二是递归结束的条件和此时函数的返回值
对求阶乘的递归函数来说 ,这两个条件可以写成下列公式
递归计算公式 p(n)=n*p(n-1)
递归结束条件 p(1)=1
在程序设计实现:
if(递归结束条件) return(递归结束条件中的返回值)
else return(递归计算公式)
消耗内存, 能用循环的话, 最好不要用递归
i = 0
def func():
global i
print('bajie: %s' % i)
i+=1
func()
func() #递归深度, 你可以自己调用自己的次数, 官方(1000)次,在这之前就会抛出异常
import sys
sys.setrecursionlimit(1000) #设置递归深度的值
print(sys.getrecursionlimit()) #查看递归深度的值
文件夹的遍历
import os
filepath = r'C:\Users\THINKPAD\PycharmProjects\s15'
def func(filepath,n):
files = os.listdir(filepath)
for file in files:
file_path = os.path.join(filepath, file)
if os.path.isdir(file_path):
print('\t'*n, file+':')
func(file_path,n+1) #为什么要用递归, 第一有相同的操作, 第二循环几次不确定
else:
print('\t'*n, file)
func(filepath,0)
二分查找
二分法进行查找,每次能够排除掉一半的数据. 查找效率非常高
要求: 查找的序列必须是有序序列
原生二分法:
lst = [1,2,4,5,9,21,23,34,35,56,87,123,231,345,678,999]
n = 35
for i in lst: #遍历查找 #最大时间复杂度o(n)
if i == n:
print('found')
break
else:
print('not found')
left = 0
right = len(lst)-1
while left <= right: #使用二分法可以提高效率(有序的才能用这种方法)(一次砍一半)
middle = (left + right)//2 #这里必须是整除
if lst[middle] > n: #2**n < 数据量; 比如1亿个数, 27次就可以找到
right = middle - 1
if lst[middle] < n:
left = middle + 1
if lst[middle] == n:
print('found')
break
else:
print('not found')
递归可以完成二分法
lst = [1,2,4,5,9,21,23,34,35,56,87,123,231,345,678,999]
def func(n,left,right):
if left <= right: #为啥不用while, 因为用了递归
middle = (left + right)//2
if n > lst[middle]:
left = middle + 1
return func(n, left, right) #递归
if n < lst[middle]:
right = middle - 1
return func(n, left, right) #递归 #返回值的问题: 如果递归了很多层, 最后一层得到结果,返回给倒数第二层, 就完事了. 如何一层层返回: return 倒数第二层给倒数第三次, 依次类推直到返回给第一层.
if n == lst[middle]:
print('found')
return middle #通过return返回, 不能用break
else:
print('not found')
return -1 #1.模仿find找不到返回 -1(一般index是整数); 2. -1 比 None好运算,可能会用到
rst = func(87, 0, len(lst)-1)
print(rst)
三.查找最快的方案
lst1 = [2,3,5,6,8]
lst2 = [0 for i in range(max(lst1)+1)] #找到列表中最大的数, 作为都是 0 的新列表的长度
for el in lst1: #把数字变成index
lst2[el] = 1
n = 1
if lst2[n] == 1: #优点o(1) 时间复杂度, 空间复杂度最低
print('it is in')
else:
print('it not in')