闭包

闭包   就是函数里面包着一个函数，里面的函数不能被直接调用

def FuncX(x):
    print("-----开始------")
    def FuncY(y):
        print("函数内")
        return x*y
    print("-----结束------")
    return FuncY  # 这里返回的是里面函数的引用
x = FuncX(3)
print(x(4))

函数很多时候要注意什么是函数引用，什么是函数调用  引用就是函数名   调用是函数名后面加了小括号

结果：-----开始------
         -----结束------
         函数内
         12

装饰器：
def FuncX(f):
    print("------开始------")
    def FuncY():
        f()  # 这里f()是函数调用
        print("函数内")
    print("-------结束------")
    return FuncY
#装饰器
@FuncX  #语法糖  语法糖的做用是把test包装起来如：FuncX(f) 这里的f=test  FuncX(test) 
def test():
    print("test......")
test()
它最后得出的结果是：
   ------开始------
   -------结束------
   test......
   函数内

一个小案例：
def liao1(a):
    def cai1():
        print("麻酱，豆皮=10")
        return 10+a()
    return cai1
def liao2(a):
    def cai2():
        print("麻酱，香菜=5")
        return 5+a()
    return cai2
@liao1
def di():
    print("锅底，羊肉=50")
    return 50
s = di()
print(s)


麻酱，豆皮=10
锅底，羊肉=50
60

@liao2
def di():
    print("锅底，羊肉=50")
    return 50
n = di()
print(n)


麻酱，香菜=5
锅底，羊肉=50
55

@liao1
@liao2
def di():
    print("锅底，羊肉=50")
    return 50
m = di()
print(m)

麻酱，豆皮=10
麻酱，香菜=5
锅底，羊肉=50
65

冒泡排序：

a=[3,5,2,6,3,8,35,63,16,9]
for i in range(len(a)):
    for j in range(len(a)-i-1):
        if a[j]>a[j+1]:
            a[j],a[j+1]=a[j+1],a[j]
print(a)

结果：[2, 3, 3, 5, 6, 8, 9, 16, 35, 63]

# sort排序
class nn:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return ("%s \t %s"%(self.name,self.age))
    def __lt__(self,ont):
        if self.name==ont.name:
            self.age<ont.age
        else:
            self.name<ont.name
nn = [nn("abc",10),nn("abc",23),nn("bca",43),nn("bbc",12),nn("bbc",21)]
nn.sort()
for q in nn:
    print(q)

结果：abc  10
          abc  23
          bca  43
          bbc  12
          bbc  21