pyhthon --递归，装饰器

递归：

递归的概念很简单，如果函数包含了对其自身的调用，该函数就是递归。拗口一点的定义是，如果一个新的调用能在相同过程中较早的调用结束之前开始，那么该过程就是递归。

"""阶乘"""
def jie(n):
    if n==0 or n==1:
        return 1
    else:
        return n*jie(n-1)
print fac(8)    

D:\python3.5\python.exe D:/untitled/python2/denglu.py
40320

Process finished with exit code 0

'''''''''''递归方式‘'''''''''''''''''

def digui(n):   #定义函数 循环后的结果
    print(n)    #输出每一次的结果
    if n == 1:   #如果不等于继续向下执行
        return 1    #返回最终的结果
    return digui(n-1) * 1  #返回的值减一在乘一
s = digui(10)    #执行函数
print(s)

 '''''''''''''''''斐波那契数列''''''''
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

def digui(a,a1,a2):         #定义函数，参数 #a = 2 a1= 13，a2 = 15 。。。。。。。。
    if a == 10:                 #判断如果q不等于10 就向下执行
        return a,a1,a2
    a3 = a1 + a2              #两数相加附一个新值 a3 等于15
    re = digui(a + 1,a2,a3)  #继续回去一级一级循环结果 最终结果484
    return re                        #定一个返回值  一级一级退出循环
z = digui(1,2,13)                  #执行函数的最终结果
print(z)

D:\python3.5\python.exe D:/untitled/python2/denglu.py
(10, 484, 783)

Process finished with exit code 0

def di(n,n1):            #定义函数 参数  0,1
    print(n)               #输 出最终的结果
    if n > 100:           #如果n（0）大于100就向下继续执行直到大于100
        return           #返回终止
    n2 = n + n1 # n=0 n1 = 1 n2 = 1
    di(n1,n2)          #两数相加继续循环
di(0,1)                  #执行函数 里的参数值

D:\python3.5\python.exe D:/untitled/python2/denglu.py
0
1
1
2
3
5
8
13
21
34
55
89
144
Process finished with exit code 0

def digui(q,q1):
    print(q,q1)
    if q == 10:
        return
    w = q2 = q + q1
    return w
s = digui(34,324)
print(s)

D:\python3.5\python.exe D:/untitled/python2/lianxi.py
34 324
358

Process finished with exit code 0

装饰器：

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。

def func(x):
    print(x)
x =123    # 实参 x 代指123
func(x)    执行函数

嵌套一层的装饰器：

def quan(yuan):#1 #定义装饰器函数， 这的参数代指的是原来(yuan1)函数
    def xin(): #2  #4  装饰器的内置函数//// 被原函数重新赋值的
        print('新的')  #5  执行函数前的操作
        ret = yuan()    #6  执行原来的函数
        print('后来的')  #10  执行后的操作
        return ret   #11  原函数的返回值
    return xin  #3   返回的新函数的返回值
@quan  #5  #7  自动应用执行装饰器的参数就是（yuan1）
def yuan1():   #原来的函数被重新赋值给了新的函数 定义为xin()
    print('原来')  #8  输出原来的值
    return 'yes'  #9  返回一个结果
s = yuan1()  #执行函数结果
print(s)

嵌套两层的装饰器：

def quan_0(gun):  #原来的yuan 函数做了两次赋值  把quan函数调用成自己的内置函数
                                    # 被quan_0代指 而这个gun参数等于quan内置函数里的gun参数
    def xin(*args,**kwargs):  #xin函数等于第二个装饰器的原来yuanl数重新第二次的赋值
        print('123')
        r = gun(*args,**kwargs)
        return r
    return xin
def quan(gun):
    def xin(*args,**kwargs):
        print("小伙")
        r = gun(*args,**kwargs)   #gun参数等于yuan函数里的参数
        print('好')
        return r
    return xin
@quan_0
@quan
def yuan(q1,q2):
    print('火了')
    return q1 + q2
s = yuan(12,21)
print(s)