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