python 返回函数无法理解_week04_python函数返回值、作用域

函数的返回值：

Python函数使用return语句返回"返回值"

所有函数都有返回值，如果没有return语句，隐式调用return None

return语句并不一定是函数的语句块的最后一条语句

一个函数可以存在多个return语句，但是只有一条可以被执行；如果没有一条return语句被执行到，

隐式调用return None

如果有必要，可以显示调用return None，可以简写return

如果函数被扫行了return语句，函数就会返回，当前被执行的return语句之后的其它语句就不会被执行了

作用：结束函数调用、返回值

举例：def showplus(x):

print(x)

return x + 1

return x + 2

print(showplus(5))# 只执行第一条return

def guess(x):

if x > 3:

return "> 3"

else:

return "<= 3"

print(guess(2))# 条件满足，只执行其中一条return

def fn(x):

for i in range(x):

if i > 3:

return i

else:

print("{} is not greater than 3".format(i))

print(fn(5))# 打印什么？

print(fn(3))# 打印什么？

函数不能同时返回多个值：def showlist():

return [1, 3, 5]

print(showlist()) #[1, 3, 5] 指明返回一个列表，是一个列表对象

def showlist():

return 1, 3, 5

print(showlist()) #(1, 3, 5) 看似返回多个值，隐式被python封装成了一个元组

函数的嵌套：

在一个函数中定义了另一个函数def outer():

def inner():

print("inner")

print("outer")

outer()# outer

inner()# NameError: name 'inner' is not defined

函数有可见范围，这就是作用域的概念；

内部函数不能被外部直接使用，会抛NameError异常；

作用域###

一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域对比一下，下面2个函数,x到底是可见还是不可见？

(1)

x = 5

def foo():

print(x)

foo()# 5

(2)

x = 5

def foo():

x += 1

print(x)

foo()# UnboundLocalError: local variable 'x' referenced before assignment

全局作用域：

在整个程序运行环境中都可见；

局部作用域：

在函数、类等内部可见；

局部变量使用范围不能超过其所在的的局部作用域；def fn1():

x = 1 # 局部作用域，在fn1内

def fn2():

print(x)# x可见吗？

print(x)# x可见吗？

嵌套结构：对比下面两个代码中变量o的差别:

(1).

def outer1():

o = 65

def inner():

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

print(chr(o))

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

inner()

outer1()

(2).

def outer2():

o = 65

def inner():

o = 97

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

print(chr(o))

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

inner()

outer2()

从上面的例子中可以看出：

外层变量作用域在内层作用域可见；

内层作用域inner中，如果定义了o = 97 ,相当于当前作用域中重新定义了一个新的变量o，但是

这个o并没有覆盖外层作用域outer中的ox = 5

def foo():

# y = x + 1

x += 1# UnboundLocalError: local variable 'x' referenced before assignment

print(x)

foo()

x += 1 其实是 x = x + 1

相当于在foo内部定义一个局部变量x，那么foo内部所有x都是这个局部变量了；

但是这个x还没有完全赋值，就被右边拿来做加1操作了；

该如何解决？？？

全局变量globalx = 5

def foo():

global x

x += 1

print(x)

foo()

使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x;

全局作用域中必须有x的定义

如果全局作用域中没有x定义会怎么样???x = 5

def foo():

global x

x = 10

x += 1# 会报错吗？

print(x)# 打印什么？

print(x)

foo()

使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x;

但是，x = 10 赋值即定义，x在内部作用域为一个外部作用域的变量赋值，所以x += 1不会报错。

注意：这里x的作用域还是全局的；

global总结：

x += 1这种是特殊形式产生的错误的原因？先引用后赋值，而python动态语言是赋值和算定义；

才能被引用。解决方法，在这条语句前增加x = 0之类的赋值语句，或者使用global告诉内部作

用域，去全局作用域查找变量定义；

内部作用域使用x = 5之类的赋值语句会重新定义局部作用域使用的变量x，但是，一旦这个作用

域中使用global声明x为全局的，那么x = 5相当于在为全局作用域的变量x赋值；

global使用原则：

外部作用域变量会内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为

函数的目的就是为了封装，尽量与外界隔离；

如果函数需要使用外部全局变量，请使用函数的形参传参解决；

一句话：不用global。学习它就是为了深入理解变量的作用域；

闭包#

自由变量：未在本地作用域中定义的变量。例如定义在内存函数外的外层函数的作用域中的变量；

闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成

了闭包。很多语言都有这个概念，最熟悉就是JavaScriptdef counter():

c = [0]

def inc():

c[0] += 1

return c[0]

return inc

foo = counter()

print(foo(), foo())

c = 100

print(foo())

代码解析：

第4行不会报错，因为c已经在counter函数中定义过了。而inc中的使用方式是为c的元素修改值，而不是重新定义。

第8行 会打印 1 2

第10行会打印 3

第9行的c和counter中的c不一样，而inc引用的是自由变量正式counter的变量c;

这就是python2中实现闭包的方式，python3还可以使用nonlocal关键字

nonlocal关键字

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

全局作用域中定义def counter():

count = 0

def inc():

nonlocal count

count += 1

return count

return inc

foo = counter()

print(foo())

print(foo())

代码解析：

count是外层函数的局部变量，被内部函数引用；

内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义；

代码可以正常使用，且形成闭包;

变量名解析原则LEGB

Local，本地作用域、局部作用域的local命名空间。函数调用时创建，调用结束消亡。

Enclosing，Python2.2时引入嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间。

Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡。

Build-in，内置模块的命名空间，生命周期从python解释器启动时创建到解释器退出时消亡。

所以一个名词的查找顺序就是LEGB