函数二

Posted 2020-12-24 cjluchen

关于默认参数的陷阱问题：

见如下代码：

def func(m=[]):#默认参数的值是可变类型
    m.append(1)
    print(m)
func()
func()
func()

#控制台输出如下：

[1]
[1, 1]
[1, 1, 1]

即如果默认参数的值是一个可变数据类型，那么每一次调用函数的时候，如果不传值就共用这个数据类型的资源。

 

 

函数的命名空间

1：内置命名空间

就是python解释器一启动就可以使用的名字，存储在内置命名空间中

内置的名字在启动解释器的时候被加载进内存里

 

2：全局命名空间

是在程序从上到下被执行的过程中依次加载进内存的，放置了我们设置的所有变量名和函数名

 

3：局部命名空间

就是函数内部定义的名字

当调用函数的时候才会产生这个名称空间，随着函数执行的结束，这个命名空间就又消失了。

 

在局部：可以使用全局，内置命名空间中的名字

在全局：可以使用内置命名空间中的名字，不能使用局部命名空间中的名字

在内置：不能使用全局，局部命名空间中的名字

多个函数应该拥有多个独立的命名空间，不互相共享

 

作用域：

全局作用域----作用在全局----内置和全局命名空间中的名字都属于全局作用域

局部作用域----作用在局部----函数（局部命名空间中的名字属于局部作用域）

 

对于不可变数据类型，在局部可以查看全局作用域中变量，但是不能直接修改，如果想要修改，需要在局部的一开始添加global声明，如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效。

 例如如下代码：

 

a=1#声明了一个全局变量a，值为1
def func():
    a=2#在局部（函数）改变a的值
func()#调用这个函数
print(a)#由输出结果可知局部的改变并没有影响到全局变量

#控制台输出
1

 

再看下面代码

a=1
def func():
    global a#在上面代码的基础上，添加global声明
    a=2
func()
print(a)#由输出结果可知，在局部声明了global后，局部的变化影响到了全局变量


#控制台输出
2

 

函数的嵌套定义：

内部函数可以使用外部函数的变量（不可变类型），但也不能直接修改，想要修改，需要在内部函数的变量前添加nonlocal声明

def outer():#定义一个外部函数
    a=1#在外部函数定义变量a
    def inner():#定义一个内部函数
        b=2
        print(a)
        print(‘inner‘)
        def inner2():#定义一个内部函数
            print(a,b)#可以查看a，b的值，但是不能直接修改
            print(‘inner2‘)
        inner2()
    inner()

outer()

#控制台输出
1
inner
1 2
inner2

如果企图在内部函数修改变量a

def outer():
    a=1
    def inner():
        b=2
        print(a)
        print(‘inner‘)
        def inner2():
            a+=1#企图在内部函数修改a
            print(a,b)
            print(‘inner2‘)
        inner2()
    inner()

outer()

#控制台输出：（报错）

UnboundLocalError: local variable ‘a‘ referenced before assignment

在内部函数为变量a添加nonlocal声明后：

def outer():
    a=1
    def inner():
        b=2
        print(a)
        print(‘inner‘)
        def inner2():
            nonlocal a#添加nonlocal声明，nonlocal只能用于局部变量，只会找上层中离当前函数最近一层的局部变量，如果最外层函数也没有这个变量，就会报错，不会去全局命名空间找，声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量
            a+=1
            print(a,b)
            print(‘inner2‘)
        inner2()
    inner()

outer()

输出为：

1
inner
2 2#可见a的值变化
inner2

 

函数名的本质：

函数名本质上就是函数的内存地址。

1.可以被引用（可以赋值）

def func():
    print(123)
func2=func#函数名可以赋值
func2()
#控制台输出：123

2.可以被当作容器类型的元素（容器类型即列表，元组，集合这些）

def func():
    print(123)
func2=func
l=[func,func2]#函数名可以作为容器类型的元素
print(l)
for i in l:
    i()

#控制台输出
[<function func at 0x000001B98ED85950>, <function func at 0x000001B98ED85950>]
123
123

3.函数名可以作为函数的参数和返回值

#函数名作为函数的参数
def func():
    print(123)

def wahaha(f):
    f()

wahaha(func)#函数名可以作为函数的参数

#控制台输出
123

#函数名作为函数的返回值
def func():
    print(123)

def wahaha(f):
    f()
    return f#函数名可以作为函数的返回值

qqxing=wahaha(func)
qqxing()

#控制台输出
123
123

所以函数是第一类对象，什么是第一类对象？

第一类对象（first-class object）指
1.可在运行期创建
2.可用作函数参数或返回值

3.可存入变量的实体。

 

不明白？那就记住一句话，就当普通变量使用

 

闭包：

内部函数包含对外部作用域而非全局作用域的名字的引用，该内部函数成为闭包函数。

def outer():
    a=1
    def inner():#这个函数就是一个闭包函数
        print(a)#如果没有这句，这个函数就不是一个闭包函数，因为内部函数没有引用外部函数的变量
outer()

想要知道一个内部函数是不是闭包函数，需要使用__closure__方法。

def outer():
    a=1
    def inner():
        print(a)
    print(inner.__closure__)#注意没有__closure__括号
outer()

#控制台输出
(<cell at 0x000001D98A4EC078: int object at 0x00000000584F22D0>,)
有cell 什么什么的，就说明是一个闭包函数

 

我们都知道如果想要在函数外部使用函数内部的变量，只需返回这个变量，同理，如果我们想在函数外部使用函数内部嵌套的函数，只需将内部函数返回即可，这就是闭包最常用的方法

def outer():
    a=1
    def inner():
        print(a)
    return inner#返回inner()函数的地址
inn=outer()#执行outer()函数，返回inner()函数的地址赋给inn变量
inn()#加上括号表示执行这个函数，inn变量里面是inner函数的地址

#控制台输出
1

闭包的好处：

若不使用闭包，则内部函数想要在外部调用必须如下操作：

def outer():
    a=1
    def inner():
        print(a)
    inner()#必须写上这句
outer()#然后再外部执行外部函数

这样每次调用outer()函数都会在内存创建a变量，结束调用后又删除a变量，浪费了很多时间，若使用闭包，当执行inn=outer()时，内部函数的地址就被inn变量保存，当结束调用后python解释器会认为变量a还有用，所以不会删除，这样以后每次要使用内部函数时，只要写inn()就可以，节省了时间。