day12_7.12递归函数与算法

一。递归函数

　　递归函数是在函数的调用阶段直接或间接的调用自己。

　　于是下面就是一个简单的递归函数：

def func():
    print('我调我自己')
    func()
func()

　　然而结果会报错，因为每个递归函数都有极限，不能无限制的调用下去，递归的极限是1000次，这个次数可以改变，使用一个sys模块：

import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(3000)
#输出结果>>>1000

　　可以通过setrecursionlimit()函数改变其极限。但即使这样递归也不该被设计成无限的，所以，递归应该有以下部分组成

　　1，函数体，2，终止条件

　　而且还需要有两个阶段：

　　1.回溯。：就是一次次重复的过程，这个重复的过程必须建立在每次重复问题的复杂度都应该下降直到有一个最终的结束条件。

　　2.递推。：一次次往回推到的过程。

　　补充：pass可以跳过语句不报错，。。。也可以，推荐使用pass

　　如题：l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]]，将列表中的数组打印出来。

　　遇到递归问题要分析问题的组成，而且人理解迭代，神理解递归，递归可以解决多数迭代解决不了的问题，

　　输出这个列表中的数分两个情况，一个是输出列表的第一个数，和输出第二个列表，所以后面输出的列表可以调用自己进行递归，

　　而输出列表可以使用for循环，当输出的数是int类型就输出其数字，否则调用自己，这样可以解决列表变量长度问题，所以可以这样解决：

l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13]]]]]]]]]]]]]
def prlist(list2):
    for i in list2:
        if type(i) is int:
            print(i)
        else:
            prlist(i)
prlist(l)

　　即可输出l。

二。二分查找算法

　　算法就是解决问题的高效率的方法。

　　如题，列表l = [1,3,5,12,57,89,101,123,146,167,179,189,345]如何搜索189是否在列表中，我们先用普通的循环法：

l = [1,3,5,12,57,89,101,123,146,167,179,189,345]
n=189
if n in l:
    print('在列表中')
else:
    print('不在')
#输出结果>>>在列表中

　　这种方法是基于遍历了整个列表然后一一比对得出的结果，但效率很低，为了减少搜索次数，使用二分法可以

l = [1,3,5,12,57,89,101,123,146,167,179,189,345]
n=189
def search(a,list1):
    if not list1:
        print('no')
        return 0
    x=len(list1)//2 #取整的
    if list1[x]==a:
        print('在里面')
    elif list1[x]>a:
        search(a,list1[:x])
    else:
        search(a,list1[x+1:])
search(n,l)
#输出结果>>>在里面

三。三元表达式

　　当我们判断两个数大小时，通常使用函数来表达

def my_max(x,y):
    if x > y:
        return x
    else:
        return y

　　这种方式所占的行数太高，过于繁琐，所以，使用三元表达式可以实现一行代码实现：

res = x if x > y else y

　　三元表达式代表的格式是：

　　值1 if 表达式 else 值2

　　当表达式成立的时候输出值1，否则返回值2，res代表的就是返回值。、

　　这个表达式不可以嵌套使用，会产生逻辑混乱，遇到三个以上的判断时使用if elif即可。

　　四。列表生成器

　　当我们需要对列表进行操作时，可以选择for循环如题

　　l = ['tank','nick','oscar','sean']，对列表中的字符串进行添加操作。加上’666‘

l1 = []
for name in l:
    l1.append('%s666'%name)
print(l1)
#输出结果>>>['tank666', 'nick666', 'oscar666', 'sean666']

　　列表生成器就可以替代这些：

res = ['%s666'%name for name in l]
print(res)

　　其中for name in l 就是一个for循环，将其列表中的元素一一拿出来进行操作 。

　　在for循环中后面可以添加判断语句，可以进一步处理数组，如将后缀为k的名字加666，其他排除：

l = ['tank','nick','oscar','sean']
res = ['%s666'%name for name in l if name.endswith('k')]
#输出结果>>>['tank666', 'nick666']

　　所以得出列表生成器的本质就是在表中for循环   [x for x in list if x 条件]

　　五。字典生成式

　　其作用是将两个列表一一对应生产一个字典，如果不使用生产式，我们可以用for循环嵌套。

l1 = ['name','password','hobby']
l2 = ['lzx','','lh','']
d = {}
for i,j in enumerate(l1):
    d[j] = l2[i]
print(d)
#输出结果>>>{'name': 'lzx', 'password': '123', 'hobby': 'lh'}

　　也可以使用更方便的字典生产式

d = {j:l2[i] for i,j in enumerate(l1)}
print(d)
#输出结果>>>{'name': 'lzx', 'password': '123', 'hobby': 'lh'}

　　注意，这的key值可以少给，但是value决对不能少给，否则会报错。

　　除了字典和列表，其实这种形式也可以生产集合和元组，和其他不一样的是元组输出的并不是元组，而是需要循环给值的东西（了解）

　　六。匿名表达式

　　也叫匿名函数，没有名字的函数，通常在使用一次之后就没了，是一次性的，临时使用。如

def my_sum(x,y):
    return x + y

　　此函数是输出两个值输出其和，而使用匿名函数可以这么写

(lambda x,y:x+y)

　　这两个函数完全等价，其代表的意义是：左边的相当与函数的形参，右边的相当于函数的返回值

　　匿名函数不可单独使用，通常配合内置函数一起使用。它的单独用法是

res = (lambda x,y:x+y)(1,2)
print(res)

　　相当于一个内存地址遇到（）后执行，其中添加参数即可。

8.常用内置函数

　　1.max()比大小

　　输入一个列表等类型的数据，返回其中最大的值，其中可以使用匿名函数对其进行修饰，应用场景在比较像字典一类的数据中value的大小，当直接返回字典给函数max时，它会直接比较key值的大小，如：

d = {
    'lzx':36660,
    'zzp':16666,
    'zzj':36600,
    'yzy':16000
}
print(max(d))
#输出结果>>>zzp

　　zzp的value并不是其中最高的，它比较的紧紧是字符串的大小，所以需要返回d[key]比较，除了另写函数传入这种方法，也可以使用匿名函数对其操作

d = {
    'lzx':36660,
    'zzp':16666,
    'zzj':36600,
    'yzy':16000
}
print(max(d,key=lambda key1:d[key1]))
#输出结果>>>lzx

　　如此返回的就是value最大的key值了。

　　2.map映射

　　将一个列表类数据传入，经过函数的操作映射出一个内存地址，可以通过循环对其进行输出，或者数据类型转换，map的匿名函数是必要参数。

list11=[1,2,2,3,22,34,21,3,1,4]
x=map(lambda x:x+2,list11)
print(x)
print(list(x))
#输出结果>>><map object at 0x000001B7F745B4A8>
#[3, 4, 4, 5, 24, 36, 23, 5, 3, 6]

　　3.zip拉链

　　将两个列表结合成一个列表，其中使用元组将两个列表中的元素对应在一起。

list11=[1,2,2,3,22,34,21,3,1,4]
list22=[123,12,312,3,12,3,23123,3]
print(zip(list11,list22))
print(list(zip(list11,list22)))
#输出结果>>>[(1, 123), (2, 12), (2, 312), (3, 3), (22, 12), (34, 3), (21, 23123), (3, 3)]

　　当两个列表不一样长时，会就短的那个一个结合。

　　拉链支持多个列表结合。

　　4.filter筛选

　　filter中是将传入的列表通过第一参数的函数判断进行筛选。filter必须要输入两个参数。是基于for循环的内置语句

list1=[1,2,3,4,5]
print(filter(lambda x:x != 1,list1))
print(list(filter(lambda x:x!=1,list1)))
#输出结果>>><filter object at 0x000001FEB56BB2E8>
#[2, 3, 4, 5]

　　5.sorted()排序

　　sorted是排序的功能，输入一个列表，如果不输入第二个参数，按从小到大的顺序进行排序，

　　输入reverse=True后，会对其进行从大到小排序。

list1=[1,2,3,4,5]
print(sorted(list1))
print(sorted(list1,reverse=True))
#输出结果>>>[1, 2, 3, 4, 5]
#[5, 4, 3, 2, 1]

　　6.reduce（func，）

　　会对序列元素进行累积，它是模块中的函数，需要调用模块

from functools import reduce

　　reduce函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

　　reduce可以传入三个参数，第三个代表的是它的初始值，如果存在初始值，就会将初始值和第一进行运算后再进行累计。

　　传入的函数需要有两个参数。

from functools import reduce
list1=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,list1))
#输出结果>>>15

　　注意这个函数输出的是一个值，而不是内存地址。