Python开发【第八篇】：Python基础之冒泡算法、递归、装饰器

一、冒泡算法

需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序

思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

li = [13, 22, 6, 99, 11]

for m in range(4):     # 等价于 #for m in range(len(li)-1):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

li = [13, 22, 6, 99, 11]

for m in range(4):     # 等价于 #for m in range(len(li)-1):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

for m in range(3):     # 等价于 #for m in range(len(li)-2):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

for m in range(2):     # 等价于 #for m in range(len(li)-3):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

for m in range(1):     # 等价于 #for m in range(len(li)-4):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp
print li

li = [13, 22, 6, 99, 11]

for i in range(1,5):
    for m in range(len(li)-i): 
        if li[m] > li[m+1]:
            temp = li[m+1]
            li[m+1] = li[m]
            li[m] = temp

二、递归

利用函数编写如下数列：

斐波那契数列指的是这样一个数列 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 f(a,b,depth):
   #print(b)
    if depth==10:
        return a
    a3=a+b
    r=f(b,a3,depth+1)
    return r
print(f(0,1,1))

 三、装饰器

写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

• 封闭：已实现的功能代码块
• 开放：对扩展开发

如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码

def outer(func):
    def inner():
        print("outer")#代表了在index()前增加的执行的语句
        r=func()
        print("inner") #代表了在index()后增加的执行语句
        print(func)#此证明了func指向了真正的index()函数
        return r
    return inner  #这句不能少，这一句的目的就是让index变量指向inner()函数

"""
1、装饰器将index()函数的内存地址，指向了func参数，那么运行func()就等于在运行真正的index()
2、装饰器将inner()函数的内存地址，指向了index，所以在执行index()函数时就等于在执行inner()。原因如下：
outer()函数的返回值是一个内存地址，然而即使加了装饰器，我们调用函数时还是使用的index()。说明python内部已经
将index变量指向了inner()函数的内存地址。
"""
@outer
def index():
    print("index")
    return True

print(index)  #此证明了index指向了inner函数
print(index())

"""
执行结果：
<function outer.<locals>.inner at 0x00636D68>
outer
index
<function index at 0x00636DB0>
True
"""

def outer(func):
    def innner(args):
        print("outer")
        r=func(args)
        print("inner")
        return r
    return innner

@outer
def f1(args):#因为f1函数已经被func代替，那么args变量也应该赋值给func()函数。
    print("f1")
    return args

print(f1(123))

"""
执行结果：
outer
f1
inner
123
"""

def outer(func):
    def innner(*args,**kwargs):
        print("outer")
        r=func(*args,**kwargs)
        print("inner")
        return r
    return innner

@outer
def f1(**args):#因为f1函数已经被func代替，那么args变量也应该赋值给func()函数。
    print("f1")
    return args

@outer
def f2(a1,a2):#因为f1函数已经被func代替，那么args变量也应该赋值给func()函数。
    print("f2")
    r=a1+a2
    return r

print(f1(k1=123))
print(f2(1,2))

"""
执行结果：
outer
f1
inner
{'k1': 123}
outer
f2
inner
3
"""

注意：因为python可以使用*args，**kwargs来代替参数化，所以在开发中强烈建议按照《多个参数》的脚本进行开发装饰器。

def outer(func):  #第一个装饰器
    def innner(*args,**kwargs):
        print("outer")
        r=func(*args,**kwargs)
        print("inner")
        return r
    return innner

def outer0(func): #第二个装饰器
    def inner(*args,**kwargs):
        print(54)
        r=func(*args,**kwargs)
        return r
    return inner


@outer0 #为了在原来的装饰器基础上，最先输出54。
#在outer0这个装饰器里，我们视outer和f1函数为一个整体，并赋值给func函数。
@outer
def f1(args):#因为f1函数已经被func代替，那么args变量也应该赋值给func()函数。
    print("f1")
    return args

@outer
@outer0  #此时将outer0放在outer下，其意义同上面一样
def f2(**args):#因为f1函数已经被func代替，那么args变量也应该赋值给func()函数。
    print("f1")
    return args

print(f1(456))
print(f2(k1=123))


"""
执行结果：
54
outer
f1
inner
456
outer
54
f1
inner
{'k1': 123}
"""