Python函数作用域

最新推荐文章于 2023-05-21 15:51:12 发布

right 先生

最新推荐文章于 2023-05-21 15:51:12 发布

阅读量289

点赞数 2

本文链接：https://blog.csdn.net/weixin_44737199/article/details/89288234

版权

函数返回值

Python函数使用return语句返回“返回值”
所有函数都有返回值，如果没有return语句，隐式调用return None
return 语句并不一定是函数的语句块的最后一条语句
一个函数可以存在多个return语句，但是只有一条可以被执行,如果没有一条return语句被执行到，隐式调用return None
如果有必要，可以显示调用return None，可以简写为return
如果函数执行了return语句，函数就会返回，当前被执行的return语句之后的其它语句就不会被执行了
返回值的作用：结束函数调用、返回“返回值

def values():
    return 1,2,3

values()

函数不能同时返回多个值
return 1, 2, 3 看似返回多个值，隐式的被python封装成了一个元组
x, y, z = values()使用解构提取返回值更为方便

函数的作用域

一个标识符的可见范围,就是标识符的作用域,一般常说变量的作用域

def foo():
    x = 100
print(x) #不可以访问

上例中x不可以访问到，会抛出异常（NameError: name ‘x’ is not defined），
原因在于函数是一个封装，它会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部x变量不可见

注意: 每一个函数都会开辟一个作用域

作用域的分类

全局作用域
在整个程序运行环境中都可见
全局作用域中的变量称为全局变量
局部作用域
在函数、类等内部可见
局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域

#局部变量
def fo1():
    x = 1     # 局部作用域，x为局部变量，使用范围在fo1内

def fo2():
    print(x)  # x不能能打印

print(x)     # x不能能打印

#全局变量 
x = 5
def foo():  #全局变量在函数外定义
    print(x)
foo()

一般来讲外部作用域变量在函数内部可见，可以使用
反过来，函数内部的局部变量，不能在函数外部看到

函数的嵌套

在函数中定义了另外一个函数

def outer():
    def inner():
        print("x")
    print("y")
    inner()
    
outer()
inner()  # 此处不可调用(inner被函数outer封装在函数内部)

内部函数inner不能在外部直接使用，会抛NameError异常，因为它在函数外部不可见。
其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已

嵌套结构的作用域

def outer():
    o = 97
    def inner():
        print("inner{}".format(o))
        print(chr(o))
    inner()
    print("outer{}".format(o))
outer()

>>>inner97
>>>a
>>>outer97

def outer():
    o = 65
    def inner():
        o = 97 
        print("inner{}".format(o))
        print(chr(o))
    inner()
    print("out{}".format(o))
outer()

>>>inner97
>>>a
>>>out65

从上面的执行结果来看:
外层变量在内部作用域可见
内层作用域inner中，如果定义了o = 97，相当于在当前函数inner作用域中重新定义了一个新的变量o，但是，这个o并不能覆盖掉外部作用域outer中的变量o。
只不过对于inner函数来说，其只能可见自己作用域中定义的变量o了

一个赋值语句的问题

 x = 5
 def foo():
     print()
foo()

函数正常执行,函数外部变量在函数内部可见

x = 5
def foo():
    y = x + 1
    #x += 1
    print(x)
foo()

当 x +=1 这一句打开后,函数报错

报错如下

原因分析：

x += 1 其实是 x = x + 1
相当于在foo内部定义一个局部变量x，那么foo内部所有x都是这个局部变量x了
x = x + 1 相当于使用了局部变量x，但是这个x还没有完成赋值，就被右边拿来做加1操作了
如何解决这个常见问题？

global语句

x = 5
def foo():    
    global x # 全局变量    x += 1    
    print(x)
foo()

使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x
全局作用域中必须有x的定义如果全局作用域中没有x定义会怎样？
如果全局作用域中没有x定义会怎样

def foo():   
    global x    
    x += 1    
print(x)
foo()

x虽然声明为全局变量,但是并未定义就拿来用了

def foo():    
    global x    
    x = 10    
    x += 1    
    print(x)
foo()
print(x)

使用global关键字定义的变量，虽然在foo函数中声明，但是这将告诉当前foo函数作用域，这个x变量将使用外部全局作用域中的x。即使是在foo中又写了x = 10，也不会在foo这个局部作用域中定义局部变量x了。

使用了global，foo中的x不再是局部变量了，它是全局变量

总结: :

x+=1这种是特殊形式产生的错误的原因？先引用后赋值，而python动态语言是赋值才算定义，才能被引用。解决办法，在这条语句前增加x=0之类的赋值语句，或者使用global 告诉内部作用域，去全局作用域查找变量定义.
内部作用域使用x = 10之类的赋值语句会重新定义局部作用域使用的变量x，但是，一旦这个作用域中使用global 声明x为全局的，那么x=5相当于在为全局作用域的变量x赋值

global使用原则:

外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，尽量与外界隔离.
如果函数需要使用外部全局变量，请尽量使用函数的形参定义，并在调用传实参解决一句话：
不用global。

闭包

自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量
闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。

def counter():
    c = [0]
    def inc():
        c[0] +=1
        return c[0]
    return inc
fo = counter()
print(fo(),fo())
c = 100
print(fo())

代码分析

第7行会执行counter函数并返回inc对应的函数对象，注意这个函数对象并不释放，因为有foo记着
第4行会报错吗？为什么
不会报错，c已经在counter函数中定义过了。而且inc中的使用方式是为c的元素修改值，而不是重新定义c变量
第8行打印什么结果？
打印 1 2
第10行打印什么结果？
打印 3
第9行的c和counter中的c不一样，而inc引用的是自由变量正是counter中的变量c

这是Python2中实现闭包的方式，Python3还可以使用nonlocal关键字再看下面这段代码，会报错吗？使用global能解决吗

def counter():
    count = 0    
    def inc():
        count += 1
        return count    
    return inc
foo = counter()
print(foo(), foo())

上述代码一定会报错,解决问题可以用global

def counter():
    global count
    count = 0    
    def inc():
        global count
        count += 1
        return count    
    return inc
foo = counter()
print(foo(), foo())

nonlocal语句

nonlocal：将变量标记为不在本地作用域定义，而是在上级的某一级局部作用域中定义，但不能是全局作用域中定义。

def counter():    
    count = 0    
    def inc():
        nonlocal count # 声明变量count不是本地变量
        count += 1
        return count    
    return inc
foo = counter()
print(foo(), foo())

count 是外层函数的局部变量，被内部函数引用。
内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义。
代码中内层函数引用外部局部作用域中的自由变量，形成闭包。

a = 50
def counter():    
    nonlocal a
    a += 1 
    print(a)
    count = 0
    def inc():
        nonlocal count # 声明变量count不是本地变量
        count += 1
        return count    
    return inc
foo = counter()
print(foo(), foo())

上例是错误的，nonlocal 声明变量 a 不在当前作用域，但是往外就是全局作用域了，所以错误。

默认值的作用域

def foo(xyz=   1):
    print(xyz)

foo() # 打印什么？
foo() # 打印什么？
print(xyz) # 打印什么？说明什么


def foo(xyz=[]):
    xyz.append(1)
    print(xyz)
foo() # 打印什么？
foo() # 打印什么？
print(xyz) # 打印什么？说明什么

    
def foo(xyz=[]):
    xyz.append(1)
    print(xyz)

        
foo() # [1]
foo() # [1,1]
print(xyz) # NameError ，当前作用域没有xyz变量

为什么第二次调用foo函数打印的是[1,1]？

因为函数也是对象，每个函数定义被执行后，就生成了一个函数对象和函数名这个标识符关联
python把函数的默认值放在了函数对象的属性中，这个属性就伴随着这个函数对象的整个生命周期
查看foo.__defaults__属性，它是个元组

def foo(xyz=[], m=123, n='abc'):
    xyz.append(1)
    print(xyz)
    
print(id(foo), foo.__defaults__)
foo()
print(id(foo), foo.__defaults__)
foo()
print(id(foo), foo.__defaults__)

>>1583908872264 ([], 123, 'abc')
>>[1]
>>1583908872264 ([1], 123, 'abc')
>>[1, 1]
>>1583908872264 ([1, 1], 123, 'abc')

函数地址并没有变，就是说foo这个函数对象的没有变过，调用它，它的属性__defaults__中使用元组保存默认值xyz默认值是引用类型，引用类型的元素变动，并不是元组的变化

非引用类型缺省值

#非引用类型缺省值
def foo(xyz, m=123, n='abc'):
    m = 456    
    n = 'def'   
    print(xyz)
    
print(foo.__defaults__)
foo('baidu')
print(foo.__defaults__) 

>>>123, 'abc')
>>>baidu
>>>(123, 'abc')

属性__defaults__中使用元组保存所有位置参数默认值，它不会因为在函数体内改变了局部变量（形参）的值而发生改变

keyword-only参数的缺省值

# keyword-only参数的缺省值
def foo(xyz, m=123, *, n='abc', t=[1, 2]):
    m = 456    
    n = 'def'    
    t.append(300)   
    print(xyz, m, n, t)
    
print(foo.__defaults__, foo.__kwdefaults__)
foo('baidu')
print(foo.__defaults__, foo.__kwdefaults__)

>>>(123,) {'n': 'abc', 't': [1, 2]}
>>>baidu 456 def [1, 2, 300]
>>>(123,) {'n': 'abc', 't': [1, 2, 300]}

属性__defaults__中使用元组保存所有位置参数默认值属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值

def x(a=[]):
    a += [5]
    
print(x.__defaults__)
x()
x()
print(x.__defaults__)


def y(a=[]):
    a = a + [5]
    
print(y.__defaults__)
y()
y()
print(y.__defaults__)  

>>>([],)
>>>([5, 5],)
>>>([],)
>>>([],)