what's the python之函数及装饰器

what's the 函数？

　　函数的定义：（return是返回值，可以没有，不过没有的话就返回了None）

def wrapper(参数1,参数2,*args,默认参数,**kwargs):
    '''注释：函数功能和参数说明'''
        函数体
        
        return 返回值

　　函数就是将要调用的内容打包装进def()里面，在不调用的情况下只读入内存不执行任何操作，若要调用时再一步一步进行。

　　函数的参数：有形参和实参两种，形参指的是定义时写在def后面的括号里，实参指调用时才会用到的代码的实际的参数，形参就是在定义阶段帮实参占位置用的。

形参：位置形参、默认参数、动态参数、命名关键字参数

　　位置形参：按照从左到右的顺序定义，必须被传值，多一个不行，少一个不行。（值经常变化时可以将其定义为位置形参）

　　默认参数：在定义函数时就已经为形参赋值，调用阶段可以不用传值（值基本不变时可以用默认参数，调用阶段就可以忽略不传值。比如矿工的性别、一个农村小学的学生的籍贯等等）。需要注意的因素：一：必须放在位置形参后面；二：默认参数通常要定义成不可变类型；三：默认参数只在定义阶段被赋值一次。

　　动态参数：实参的长度不固定是就用动态参数*args*和*kwargs，可以接受任意类型

　　命名关键字参数：定义在*后的形参，这类形参，必须被传值，而且要求实参必须是以关键字的形式来传值，如：

def register(*args,name='egon',age):
    print(args)
    print(name)
    print(age)
#
# register(name='egon',age=18)
register(1,2,2,3,age=10)

形参的定义顺序为：位置形参，默认参数，*args，命名关键字参数，**kwargs

实参：位置实参、关键字参数（位置实参必须在关键字实参前面）

　　位置实参：与位置形参相对应，统称为位置参数

　　关键字参数：以key=value的形式指名道姓的传值，可以不用像位置实参一样与形参一一对应

 

---

 

 

what's the 命名空间？

命名空间：内置命名空间、全局命名空间、局部命名空间

加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载）

相对应的变量即全局变量和局部变量，局部变量的取值顺序为：

　　　　　　　　　　在局部调用：局部命名空间->全局命名空间->内置命名空间；

　　　　　　　　　　在全局调用：全局命名空间->内置命名空间

 

函数的嵌套：定义的函数中可再定义函数，内部的函数就是嵌套进去的函数，要记住凡是函数都有返回值return

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。函数的作用域关系在函数定义阶段就已经固定，与调用位置无关，无论函数在何处调用，都需要回到定义阶段去找对应的作用域关系

 

nonlocal关键字的运用：

# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量，如果外部有这个变量的只在第一层函数中生效

def f1():
    a = 1
    def f2():
        nonlocal a
        a = 2
    f2()
    print('a in f1 : ',a)

f1()

 

　　函数名的本质是函数的内存地址，可以被引用，可以被当作容器类型的元素，可以当作函数的参数和返回值。函数名可以当普通变量使用。

注：

第一类对象（first-class object）指
1.可在运行期创建
2.可用作函数参数或返回值
3.可存入变量的实体。

 

 

---

 

闭包函数：在函数内部再定义一个函数，该内部函数包含对外部作用域，而不是对全局作用域名字的引用那么该内部函数就叫闭包函数。（该函数即使不return也算闭包函数）

　　闭包函数的特点就是自带作用域，即始终携带其外部作用域的变量，即使在调用时在其外部再设置一个不同值的相同变量也不能改变其携带的变量的值。

定义闭包函数的基本形式：

def 外部函数名():
    内部函数需要的变量
    def 内部函数():
        引用外部变量
    return 内部函数

举个小栗子：

def func():#以下缩进内容就是一个闭包函数
    name='alex'
    def bar():
        print(name)
    return bar
b=func()#因为func()return出了bar，所以b就等于bar
b()#这个b()就是bar()，就是一个闭包函数

 

查看闭包函数的一个方法：print(b.__closure__[0].cell_contents)  #如果结果是None，就说明不是闭包函数。

　　b就是指闭包，__closure__指查看携带的变量的id，[0]指的是携带的第一个变量，cell_contents值的是查看携带的变量的值。

 

闭包函数的一个应用就是装饰器，装饰器的诞生是因为代码的修改遵循开放封闭原则——已经实现功能的代码不能被修改，但是可以被扩展。就是因为不能被修改，所以才有了装饰器，以起到不修改源代码的前提下对其效果进行修改的作用。

装饰器的基本形式：

#装饰器
def wrapper(func):
    def inner(*args,**kwargs):#定义函数的时候——*参数的聚合
        ret = func(*args,**kwargs)  #调用函数的时候——*参数的打散
        #func是被装饰的函数，ret是被装饰函数的返回值
        return ret #把被装饰的函数的返回值返回给调用者
    return inner

调用装饰器的方法是在要调用的函数的正上方@装饰器，该方式名为语法糖。

 

带开关的装饰器： 

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print('''执行函数之前要做的''')
            re = func(*args,**kwargs)
            if flag:
                print('''执行函数之后要做的''')
            return re
        return inner
    return timer

@outer(False)#参数是False表示关掉装饰器,True表示开启
# 开启装饰器就会执行代码中的中文，也就是执行想要用装饰器修改原来代码的功能的部分
def func():
    print(111)

func()

 

 

一个函数可以被多个装饰器装饰，一个装饰器可以装饰多个不同的函数。

当一个函数被多个装饰器装饰时，首先要运行最上面的装饰器，下面举个小栗子：

def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner

def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner

@wrapper2#装饰器装饰了被装饰过后的函数，所以对这个装饰器而言下面的都是一个函数，即打印时的顺序为最上面的装饰器先运行
@wrapper1#装饰器装饰了f()
def f():
    print('in f')

f()
'''
打印结果为
wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func
'''