day4之内置函数、匿名函数，递归函数

内置函数：

https://www.processon.com/view/link/5adc6062e4b04721d63171eb?pw=3218

匿名函数：lambda

lambda 语法： lambda 参数： 表达式

lambda存在意义就是对简单函数的简洁表示。

# 现有两元组 (('a'),('b')), (('c'), ('d'))，请用python中的匿名函数生成[{'a':'c'}, {'b':'d'}]

# t1 = (('a'),('b'))
# t2 = (('c'), ('d'))
# print(list(zip(t1, t2)))
# def func(t):
#     return {t[0]: t[1]}
# m1 = map(func,zip(t1, t2) )
# print(list(m1))
# ==
# m1 = map(lambda t: {t[0]: t[1]}, zip(t1, t2))
# print(list(m1))

以下代码的输出是什么？ 请给出答案并解释

# def multipliers():
#     return [lambda x: i*x for i in range(4)]
"""
def  multipliers():
    retun [lambda x: i*x,lambda x: i*x,lambda x: i*x,lambda x: i*x]
每次循环i都会被重新赋值给，最终i == 3
"""
#
# print([m(2) for m in multipliers()])
# 结果：
# [6, 6, 6, 6]
'''
执行[lambda x: i*x,lambda x: i*x,lambda x: i*x,lambda x: i*x]这个四个函数x都==2，i== 3
'''

# 想要产生 0， 2， 4， 6的话，可以修改为生成器表达式，因为生成器默认是取值的时候才会执行的，所以i分别取值为[0,1,2,3]
# def multipliers():
#     return (lambda x: i*x for i in range(4))
# print([m(2) for m in multipliers()])

1.map函数，我们使用map函数将会对列表中的所有元素进行操作。map有两个参数（函数，列表），它会在内部遍历列表中的每一个元素，执行传递过来的函数参数。在输出到新列表中。

1 li = [11, 22, 33]
2 new_list = map(lambda a: a + 100, li)
输出：[111, 122, 133]

当然，map还可以完成多个数组的相加：

1 li = [11, 22, 33]
2 sl = [1, 2, 3]
3 new_list = map(lambda a, b: a + b, li, sl)
4 print new_list
输出：[12, 24, 36]

2.reduce函数，对于序列内所有元素进行累计操作：

1 lst = [11,22,33]
2 func2 = reduce(lambda arg1,arg2:arg1+arg2,lst)
3 print 'func2:',func2
输出：func2: 66

3.filter函数，他可以根据条件对数据进行过滤：

1 li = [11, 22, 33]
2 new_list = filter(lambda arg: arg > 22, li)
3 print new_list
输出：[33]

递归函数

我们先来讲一个故事，讲的什么呢？从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么呢？

从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么呢？

从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么呢？

从前有座山，山里有座庙，庙里有个老和尚讲故事，讲的什么呢.....

.这个故事你们不喊停我能讲一天！我们说，生活中的例子也能被写成程序，刚刚这个故事，让你们写，你们怎么写呀？

while True:
    story = "
    从前有个山，山里有座庙，庙里老和尚讲故事，
    讲的什么呢？
    "
    print(story)

函数的执行方式：

def story():
    s = """
    从前有个山，山里有座庙，庙里老和尚讲故事，
    讲的什么呢？
    """
    print(s)

while True:
    story()

递归的方式实现：

def story():
    s = """
    从前有个山，山里有座庙，庙里老和尚讲故事，
    讲的什么呢？
    """
    print(s)
    story()

story()

初识递归

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

　　递归的最大深度——1000

# def func(n):
#     print('--->', n)
#     func(n+1)
# func(0)  #-->RecursionError: maximum recursion depth exceeded while calling a Python object

# python默认的最大递归层数是998层

测试最大递归深度

获取与设置最大深度

import sys
# print(sys.getrecursionlimit())  获取最大递归层数
# sys.setrecursionlimit()  设置递归深度

"""
setrecursionlimit(n)

Set the maximum depth of the Python interpreter stack to n.  This
limit prevents infinite recursion from causing an overflow of the C
stack and crashing Python.  The highest possible limit is platform-
dependent.
"""

# def age(n):
#     if n == 1:
#         return 18
#     return age(n-1) + 2
# print(age(5))

递归实例1

# 递归打印list中子元素不包含list的元素
# l1 = [1, [2, [3, [4, [5, [6]]]]]]
# def func(l):
#     for n in l:
#         if type(n) is list:
#             func(n)
#         else:
#             print(n)
#
# func(l1)

递归实例2

# 递归总结
# 1、必须有一个明确的结束条件
# 2、每次进入更深一层递归时，问题规模比上次递归应所有减少
# 3、递归效率不高

递归函数与三级菜单

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

menu

递归实现三级菜单

l = [menu]
while l:
    for key in l[-1]:print(key)
    k = input('input>>').strip()   # 北京
    if k in l[-1].keys() and l[-1][k]:l.append(l[-1][k])
    elif k == 'b':l.pop()
    elif k == 'q':break