day14_递归、匿名函数、内置函数

目录

递归

递归思想

一种特殊的函数嵌套调用：函数定义时，间接或者直接调用自身

  • 每调用一次，下一层的问题规模将会减小
  • 必须有条件使得函数不再调用自身，即开始回溯之前重复调用的函数
def print_user(n):
    print(n,'from print_user')
    n += 1
    if n > 100:
		return
    print_user(n)
    
print_user(20)

汉诺塔问题

分析：

第一步：假设已经将上面的n 层 从 a -> c : 先将上面n-1层转移到b，那么再把第n层转移到c，再把b上的n-1层移动到c即可，第二步再考虑怎么将b上的n-1层转移到c

第二步：将上面的n-1 层 从 b -> c : 假设已经将上面n-2层转移到a,再把第n-1层转移到c，再把a移动到c，第三步再考虑怎么将a上的n-2层转移到c

第三步开始重复第一步：将上面的n-2层从 a -> c :

...

直到最后：将上面的2层从a->c

def hanot(a,b,c,n):
    if n == 2:  #最后一步
        print(f'{a}->{b}')
        print(f'{a}->{c}')
        print(f'{b}->{c}')
        return
    hanot(a,c,b,n-1)  # 第一步
    print(f'{a}->{c}')  # 第二步
    hanot(b,a,c,n-1)  # 第三步

匿名函数

有名函数

def func():
    pass

匿名函数

lambda 参数：返回值

匿名函数就是没有函数名的函数对象

# 一次传入多个参数，返回函数对象
res = lambda x,y:x if x>y else y
print(res,type(res))
print(res(1,6))
'''
<function <lambda> at 0x0000023D82082F78> <class 'function'>
6
'''

一般不单独使用，常与其他函数连用

与内置函数连用

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

max()

单独一个可迭代对象作为参数

# 单独一个可迭代对象作为参数
res1 = max(salary_dict)

# 单独一个可迭代对象iter作为参数,并传入一个函数对象fun，迭代取出la中的元素传入func，将func的返回值作为比较值，最终返回最大值在la中对应的元素
def func(k):
    return salary_dict[k]
res2 = max(salary_dict,key=func)

lt = [2,3,5,6,8]
res3 = max(lt,key=lambda item: item if item > 2 else 10)
print(f'res1:{res1},res2:{res2},res3:{res3}')
'''
res1:tank,res2:jason,res3:2'''

大于等于两个参数

res = max(1,2,5,3,7,6)

map()

第一个参数为函数对象func，第二个参数为可迭代对象iter，结果为可迭代对象map object

  • 首先将可迭代对象变成迭代器对象
  • 通过__next__迭代取出迭代器可迭代对象中的一个个元素i，依次作为参数传给func(i)，得到一个个结果res存放到可迭代对象map object中
lt = [1,2,3,4]
# 使用有名函数对象作为参数
def func1(x):
    return x**2
res = map(func1,lt)
print(list(res))

# 使用匿名函数作为参数（匿名函数就是没有函数名的函数对象）
res = map(lambda x:x**3,lt)
print(list(res))
'''
[1, 4, 9, 16]
[1, 8, 27, 64]
'''

filter()

通过func筛选

第一个参数为函数对象func或None，第二个参数为可迭代对象，返回结果为可迭代对象filter object

  • 首先将可迭代对象变成迭代器对象
  • 如果第一个参数是None，则将所有的元素存放到filter object中
  • 如果第一个参数为函数对象func，通过__next__迭代取出迭代器可迭代对象中的一个个元素i，依次作为参数传给func(i)，得到一个个结果res
  • 如果res为True，就存放到可迭代对象filter object中
lt = [1,2,3,4]
def func1(x):
    if x > 2:
        return x**2

res1 = filter(func1,lt)
res2 =filter(None,lt)
print(list(res1),list(res2))
'''
[3, 4] [1, 2, 3, 4]'''

sorted()

内置函数

常用内置函数

enumerate()

带有索引的迭代

l = ['a','b','c']
for item in l:
    print(item)
'''
(0, 'a')
(1, 'b')
(2, 'c')'''

eval()

把字符串翻译成数据类型，不能为空

自动去除空格，换行符

str_list = "[1,2,3,4]  \n"
data = eval(str_list)
print(data,type(data))
'''
[1, 2, 3, 4] <class 'list'>'''

其他

bytes():转化为二进制编码

chr()/ord():参考ASCII码表将数字转成对应字符/将字符转换成对应的数字

divmod():分栏

hash():是否可哈希

posted @ 2019-09-25 20:18  W文敏W  阅读(123)  评论(0)    收藏  举报