内置函数，匿名函数，递归

内置函数：

详查下网址

https://docs.python.org/3/library/functions.html?highlight=built#ascii

divmod(x, y)　　　　　　　　　  　 # (商， 模)
enumerate(可迭代对象) 　　　  　   # (序号，值)
eval(字符串) 　　　　　　　　　　 # 把字符串当成命令执行
frozenset({1,2,3})　　　　　　        # 不可变集合
globals() 　　　　　　　　　　　   # 查看全局变量
locals()　　　　　　　　　　　 　  # 查看局部变量
isinstance(3, int)　　　　　　   　   # 查看3是不是int类型
pow(3,3) 　　　　　　　　　　      # 3**3
pow(3,3,2)　　　　　　　　　　   # 3**3 % 2
reversed()　　　　　　　　　　    # 翻转
round(3.3456, 3)　　　　　　　　  # 保留3位小数后四舍五入

zip()：拉链函数

　　s = 'hello'
　　l = [1,2,3,4,5,6]
　　zip(s,l) 

map:映射，每个元素执行lambda表达式结果
l=[1,2,3,4]
m = map(lambda x:x**2, l)
生成一个迭代器，循环后结果
print(list(m))
>>[1,4,9,16]

reduce:合并

from functools import reduce

reduce(合并规则(func),可迭代对象range(100),初始值)

filter
filter(lambda, 列表) # 打印返回结果为True的值

sorted:排序，没有改变原来的顺序
sorted(list)
sorted(list, reverse=True)

匿名函数：

1 #这段代码
2 def calc(n):
3     return n**n
4 print(calc(10))
5  
6 #换成匿名函数
7 calc = lambda n:n**n
8 print(calc(10))

递归：

递归特性:

1. 必须有一个明确的结束条件（否则容易死循环）

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def febo(n):
    if n == 1 or n == 2:
        return 1
    else:febo(n-1)+febo(n+1)


def  febo(n):
    a,b=0,1
    res=[]
    for i in range(n):
        c=b
        b=a+b
        a=c
        res.append(b)
    return res

'''实现一个输出前 30 个整数的阶乘的程序。
n! 的阶乘定义为：n! = n * (n-1)!, 0! = 1，因此它非常适合使用递归函数来实现。''

def func(n):
    res=1
    if n>0:
        res=n*func(n-1)
    return res

print(func(30))