递归调用、二分法、匿名函数和内置函数

递归调用

递归调用

1、在调用一个函数的过程中，直接或者间接又调用该函数本身，称为递归调用
2、递归必备的俩个阶段：

1、递推
2、回溯

#修改最大递归层数
import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())

l=[1,[2,[3,[4,[5,[6,[]]]]]]]
def func(l):
    for item in l:
        if type(item) is list:
            func(item)
        else:
            print(item)
func(l)
###########################################
#age(3)=age(2)+2
#age(2)=age(1)+2
#age=18
#age(n)=age(n-1)+2
#age(1)=18
def age(n):
    if n == 1:
        return 18
    return age(n-1)+2
res=age(200)
print(res)

二分法

匿名函数

1、有名的函数，可以重复调用，匿名函数就相当于只有一个内存地址
2、匿名函数指声明了一个内存地址，直接打印就能看到函数的返回值
3、
max，min，sorted，map，reduce，filter

lambda函数

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
#有名字的函数：
def my_sum(x,y):
    return x+y
print(my_sum(1,2))

#使用匿名函数：
print((lambda x,y:x+y)(1,2))


print(max(salaries,key=func))#key=func('egon')

print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))

#如：
def sayhi(n):
    print(n)

sayhi(5)
(lambda n:print(n))(5)

calc=lambda n:3 if n <4 else n
print(calc(5))

def lam(n):
    calc=[3 if n <4 else n ]
lam(5)

Max,min函数

for 循环salaries，取出字典的key，key=func，当做参数传给func，把func函数的返回值，赋值给key，当做比较依据。

#max，min
def func(k):
    return salaries[k]
print(max(salaries,key=func))#key=func('egon')
print(max(salaries,key=lamdba k:salaries[k]))
print(min(salaries,key=lamdba k:salaries[k]))

sorted函数：

# sorted,
print(sorted(salaries,key=lambda k:salaries[k]))
#reverse=True的意思是取反的意思
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

#如：
a={4:2,1:0,10:-121,-4:-21}
print(sorted(a))
print(sorted(a.items()))
print(sorted(a.items(), key=lambda x:x[1]))
>>>
>[-4, 1, 4, 10]
[(-4, -21), (1, 0), (4, 2), (10, -121)]
[(10, -121), (-4, -21), (1, 0), (4, 2)]

map函数，映射

# map,
names=['alex','wupeiqi','yuanhao']
# l=['%s_sb'%name for name in names ]
# print(l)
g=map(lambda name:'%s_db'%name,names)
# print(list(g))
print(next(g))
print(next(g))
print(next(g))

filter函数，过滤功能

# filter
names=['alex_sb','wupeiqi','yuanhao']
#filter(lambda x:if x.endswith('sb'),names) #第二个参数为迭代器，然后使用for循环names，x:后面判断下值里面是否是sb
filter(lambda x:x.endswith('sb'),names)

reduce函数，合并

# reduce,
from  functools import reduce
reduce(lambda x,y:x+y,range(100))
print(reduce(lambda x,y:x+y,range(100)))

内置函数

需要掌握的函数

divmod #意思是第一个值除第二个字，等于多少余一个多少

print(divmod(1002,25))

enumerate #打印每一个vlues的index，值

l=['a','b','c']
for i in l:
    print(l.index(i),i,)

for i,v in enumerate(l):
    print(i,v)

eval #把字符串类型的列表转换为list

res=eval('[1,2,3,4,5,6]')
print(res,type(res))
#exec  #单纯的执行str
res=exec('[1,2,3,4,5,6]')
print(res,type(res))

pow #pow #2的3次方，除3取余

res=pow(2,3,3)
print(res)

round #round #四舍五入

print(round(2.5))

了解的

print(abs(-1)) #数字取绝对值

print(all([1,2,'a','z'])) #全部为真就为真
print(all([None])) #为假的有False、None、0

print(bin(11))  #转换二进制
print(hex(11))  #转换十六进制

import os
# print(dir(os))  #返回这个模块可用的内置函数

s=frozenset({1,2,3}) #不可变集合

print(hash('xxx')) #转换为hash