Python语法--------函数--返回值&作用域

# return语句之后可以执行吗
def showplus(x):
    print(x)
    return x + 1
    print('~~end~~')            #return之后会执行吗
showplus(5)

# 多条return语句都会在执行吗?
def showplus(x):
    print(x)
    return x + 1
    return x + 2
showplus(5)



# 下例多个return可以执行吗?
def guess(x):
    if x > 3:
        return "> 3"
    else:
        return "<= 3"
print(guess(10))




# 下面函数执行的结果是什么
def fn(x):
    for i in range(x):
        if i > 3:
            return i
        else:
            print("{} is not greater than 3".format(x))
print(fn(5))
print(fn(3))

(一)总结

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

def showvalues():
    return 1, 3, 5

showvalues

(1, 3, 5)#返回一个值,封装成一个元组

• 函数不能返回多个值
• return 1, 3, 5看似返回多个值,隐式的被Python封装成了一个元组
• x, y, z = showlist() 使用解构提取返回值更加方便

(二)函数作用域

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

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

上例中x不可以访问到,会抛出异常(NameError:Name’x’is not defined),原因在于函数是一个封装,它会开辟一个作用域,x变量被限制在这个作用域中,所以在函数外部x变量不可见
注意:每一个函数都会开辟一个作用域

(三)作用域分类

• 全局作用域
  在整个程序运行环境中都可见
  全局作用域中的变量称为全局变量

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

• 局部作用域
  在函数,类等内部可见
  居普作用域中的变量称为局部变量,其使用范围不能超过其所在局部作用域

def f2():
    x = 1
def f3():
    print(x)
print(x)
f3

• 总结
  一般来说外部作用域变量在函数内部可见,可以使用
  反过来,函数内部的局部变量,不能在函数外部看到

(四)函数嵌套

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

def outer():
    def inner():
        print("inner")
    print("outer")
    inner
outer() # 打印成功
inner() # NameError: name 'inner' is not defined

inner不过就是一个标识符,就是一个函数outer内部的变量而已

• 嵌套解构的作用域
  对比下面嵌套结构,代码执行结果

def outer1():
    o = 65
    def inner():
        print("inner {}".format(o))
        print(chr(o))

    inner()
    print("outer {}".format(o))
outer1()




inner 65
A
outer 65

def outer2():
    o = 65
    def inner():
        o = 07
        print("inner {}".format(0))
        print(chr(o))

    inner()
    print("outer {}".format(o))
outer2()




inner 97
a
outer 65

• 从执行结果来看:

内层作用域inner中,如果定义了o=97,相当于在当前函数inner作用域中重新定义了一个新的变量o,但是这个o并不能覆盖掉外部作用域outer2中的变量o,只不过对于inner函数来说,其只能可见自己作用域中定义的变量o了

(五)一个赋值语句的问题

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

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

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

foo()

执行报错,报错如下

UnboundLocalError: local variable ‘x’ referenced before assignment

• 原因分析
  x += 1其实是x = x + 1
  相当于在foo内部定义一个局部变量x,那么foo内部所有x都是这个局部变量x了
  x = x + 1相当于使用了局部变量x,但是这个x还没有完成赋值,就被右边拿来做加1操作了

(六)global语句

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

• 使用global关键字的变量,将foo内的x声明为使用外部的全局作用域中定义的x
• 全局作用域中必须由x的定义

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

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

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

• 使用了global,foo的x中的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
foo = counter()
print(foo(),foo())
c = 100
print(foo())

• 代码解析
  第七行执行counter函数并返回inc对应的函数对象,注意这个函数对象并不释放,因为有foo记着
  第四行不会报错,c已经在counter函数中定义过了.而且inc中的使用方式是为c的元素死u改制,而不是重新定义c变量
  第八行打印 1 2
  第十行打印 3 ,

(八)nonlocal语句

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

上例中使用globa解决,这是全局变量的实现,而不是闭包了.
如果要对这个普通变量使用闭包,Python3中可以使用nolocal关键字

• nonlocal语句
  将变量标记为不在本地作用域定义,而是在上级的某一级局部作用域中定义,但不能是全局作用域中定义.

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

count是外层函数的局部变量,被内部函数引用.
内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义.
代码中内层函数引用外部局部作用域中的自由变量,形成闭包
nonlocal不能作用到全局作用域,
#下例错误#

a = 50 
def counter():
    nonlocal a
    a += 1
    print(a)
counter()

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

(九)默认值的作用域

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

foo()
foo()
print(xyz)

[1]
Traceback (most recent call last):
[1, 1]
NameError: name 'xyz' is not defined

• 函数也是对象,每个函数定义后,每个函数被执行后,就生成了一个函数对象和函数名这个标识符关联
• 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__)



1947518911080 ([], 123, 'abc')
[1]
1947518911080 ([1], 123, 'abc')
[1, 1]
1947518911080 ([1, 1], 123, 'abc')

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

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

print(foo.__defaults__)
foo('Python')
print(foo.__defaults__)



(123, 'abc')
Python
(123, 'abc')

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

# kwyword-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('Python')
print(foo.__defaults__,foo.__kwdefaults__)


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

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

(十)列表缺省值

• +表示两个列表合并并返回一个全新的列表
• +=表示,就地修改前一个列表,在其后追加后一个列表,就是extend方法

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],)
([],)
([],)

(十一)变量名解析式原则LEGB

• local,本地作用域,局部作用域的local命名空间.函数调用时创建,调用结束消亡
• Enclosing,Python2.2时引入了嵌套函数,实现了闭包,这个就是嵌套函数的外部函数的命名空间
• Global,全局作用域,即一个模块的命名空间.模块被import时创建,解释器推出时消亡
• Build-in,内置模块的命名空间,生命周期从Python解释器启动时创建到解释器退出时消亡.例如print(open),print和open都是内置的变量
  所以一个标识符的查找顺序就是LEGB