一、定义
    函数式就是用编程语言去实现数学函数。这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数，没for和while循环
所有的循环都由递归去实现，无变量的赋值（即不用变量去保存状态），无赋值即不可改变。
二、特点
    1、不可变数据
        不可变：不用变量保存状态，不修改变量
        a. 非函数式
            a = 1
            def test():
                global a
                a += 1
                return a
            test()
            print(a)
            >>> 2
        b. 函数式
            n = 1
            def test1(n):
                return n+1
            print(test1(2))
            print(n)
            >> 3
               1
    2、第一类对象
        第一类对象：函数即变量
        a.函数名可以作为参数传递
            def a(n):
                print(n)
            def b(name):
                print('My name is %s'%name)
            a(b)
            >>> 上述调用为：b不带括号则表示b函数的内存地址，将内存地址作为实参传递给a函数，则a函数打印的为b函数的内存地址
            a(b('Liming'))
            >>> 'My name is Liming'
                None
                上述调用为：首先会执行函数b，则先打印出‘My name is Liming’，但是b函数没有定义返回值，则默认为None
            则将None作为实参传递给a函数，则a函数打印出None
        b.返回值可以是函数名
            def a():
                print('from a')
            def b():
                print('from b')
                return a
            n = b()
            n()
            >>> 'from a'
                'from b'
    3、尾调用优化（尾递归）
        尾调用：在函数的最后一步调用另外一个函数（最后一行不一定是函数的最后一步）
        尾调用优化：尾调用的关键就是在于函数的最后一步调用别的函数，这样的好处是：根据函数即‘变量’的定义，
    定义a函数，a内调用b函数，b内调用c函数，在内存中会形成一个调用记录，又称调用帧，用于保存调用位置和内部变
    量等信息，即a->b->c直到c返回结果给b，c的调用记录才会消失，b返回给a，b的调用记录消失，a返回结果，a的调用
    记录消失，所有的调用记录都是先进后出，形成了一个调用栈。尾调用由于是函数的最后一步操作，所以不需要保留外
    层函数的调用记录，因为调用位置、内部变量等信息都不会用到了，只要直接用内层函数的调用记录，取代外层函数的
    调用记录就可以了。
        def bar(n)
            return n
        def foo(x):
            return bar(x)
        print(foo(3))
        >>> 3
        上述foo(3)就等于bar(3)，也就是说foo在最后一步调用了bar，然后foo的调用记录就清楚了，剩下的就是bar
    自己的事情了。所以内存里永远只保留一个调用记录。

        尾递归：函数调用自身成为递归，如果尾调用自身，就成为尾递归。
        尾递归特点：重复相同的事情，每次重复会使问题规模减少。
        尾递归举例：
            问题：师傅，北京怎么去啊？
            解决方法：a去问b，b不知道，b去问c，c去问d，最有由d得出结果，此过程可以发现，问题最有只需要d去
        结局即可，a b c都无需保存任何记录，不干事，因为他们啥都不知道。
        尾递归优点：递归通常非常耗费内存，因为需要同时保存成千上百个调用记录，很容易发生‘栈溢出’错误。
    但对于尾递归来说，由于只存在一个调用记录，所以不会发生‘栈溢出’错误。
        def cal(l):
            print(l)
            if len(l) == 1:
                return l[0]
            first,second,*args = l
            l[0] = first + second
            l.pop(1)
            return cal(l)
        x = cal([i for i in range(10)])
        print(x)
        >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
            [1, 2, 3, 4, 5, 6, 7, 8, 9]
            [3, 3, 4, 5, 6, 7, 8, 9]
            [6, 4, 5, 6, 7, 8, 9]
            [10, 5, 6, 7, 8, 9]
            [15, 6, 7, 8, 9]
            [21, 7, 8, 9]
            [28, 8, 9]
            [36, 9]
            [45]
            45
        上例就是用到尾递归，最终求得1~9的和