day15 python lambda函数递归函数二分法

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')

巴特西

day15 python lambda函数递归函数二分法

最新文章

热门文章

巴特西

day15 python lambda函数 递归函数 二分法

最新文章

热门文章

day15 python lambda函数递归函数二分法