BTW
- Python函数使用return语句返回"返回值"
- 所有函数都有返回值,如果没有return语句,饮食调用return None
- return语句并不一定是函数的语句块的最后一条语句
- 一个函数可以存在多个return语句,但是只有一条可以被执行。如果没有一条return语句被执行到,隐式调用return None
- 如果有必要,可以显示调用return None,可以简写为return
- 如果函数执行了return语句,函数就会返回,当前被执行的return语句之后的其他语句就不会被执行了
- 返回值的作用:结束函数调用,返回"返回值"
def showvalues():
return 1,2,3
showvalues()
(1, 2, 3)
a,b,c = showvalues() #解构
print(a,b,c)
1 2 3
- return不能返回多个值
- 当return返回多个值时,会将多个值封装成一个元祖
- 被封装成的元祖可以被解构
函数作用域
作用域
一个标识符的课件范围,这就是标识符的作用域,一般常说的变量的作用域
def foo():
x = 100
tpye(x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-35-0ed6a7146749> in <module>
----> 1 tpye(x)
NameError: name 'tpye' is not defined
不可以访问到,原因是函数是一个封装,它会开辟一个作用域,x变量被限制在这个作用域中,所以在函数外部x变量不可见。(每一个函数都会开辟一个作用域)。
作用域分类
- 全局作用域
在整个程序运行环境中都可见
全局作用域中的变量称为全局变量 - 局部作用域
在函数、类等内不可见
局部作用域中的变量称为局部变量,其使用范围不能超过其所在局部作用域。
def fn1():
x = 1
def fn2():
print(x)
fn2()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-39-e87bcb52744c> in <module>
----> 1 fn2()
<ipython-input-38-7fac7d12782b> in fn2()
2 x = 1
3 def fn2():
----> 4 print(x)
NameError: name 'x' is not defined
=================================================================================
print(x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-40-fc17d851ef81> in <module>
----> 1 print(x)
NameError: name 'x' is not defined
函数嵌套
在一个函数定义了另外一个函数
def outer(): #将标识符与函数对象做绑定关系
def inner():
print('inner')
print('outer')
inner()
outer()
outer
inner
=====================================================
inner()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-43-7f0826fa8974> in <module>
5 inner()
6 outer()
----> 7 inner()
NameError: name 'inner' is not defined
封装在函数内部的函数封装对外是不可见的及不可调用,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 = 97
print("inner {}".format(o))
print(chr(o))
inner()
print('oouter {}'.format(o))
outer2()
inner 97
a
oouter 65
从执行的结果来看:
-
外层变量在内部作用域可见
-
内层作用域inner中,如果定义了o = 97,相当于在当前函数inner作用域中重新定义了一个新的变量o,但是,这个o并不能覆盖掉外部作用于outer2中的变量o,只不过对inner函数来说,其只能可见自己作用域中定义的变量o了
-
赋值语句:
x = 6
def add():
a = x + 1
return a
add()
7
==========================================================================
x = 6
def add():
x += 1
return a
add()
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
<ipython-input-48-15ca56e81ced> in <module>
3 x += 1
4 return a
----> 5 add()
<ipython-input-48-15ca56e81ced> in add()
1 x = 6
2 def add():
----> 3 x += 1
4 return a
5 add()
UnboundLocalError: local variable 'x' referenced before assignment
分析为什么a = x+1 和 x += 1:
- x += 1 就是 x = x+1
- 相当于在foo内部定义一个局部变量x,那么foo内部所有x都是这个局部变量x了
- a = x + 1相当于使用了局部变量x,但是这个x还没有完成赋值,就被右边拿来加1操作了
global语句
x = 1
def foo():
global x
x += 1
print(x)
foo()
2
- 使用global关键字的变量,将foo内的x声明为使用外部的额去阿奴作用域中定义的x
- 全局作用域必须有x的定义
def foo():
global x
x += 1
print(x)
foo()
NameError: name 'x' is not defined
============================================================
def foo():
global x
x = 10
x += 1
print(x)
foo()
11
print(x)
11
==================================================================
x = 10
def foo():
global x
x = 6
x += 1
print(x)
foo()
7
print
7
使用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
闭包
- 自由变量:未在本地作用域中定义的变量,例如定义在内层函数外的外层函数的作用域中的变量
- 闭包:出现在嵌套函数中,指的是内层函数引用到了外层函数的自由变量,就形成了闭包。javascript也使用了这个概念
nonlocal语句
nonlocal:将变量标记为不在本地作用域定义,而是在上级的某一级局部作用域中定义,但不能是全局作用域中定义
def counter():
count = 0
def inc():
nonlocal count
count += 1
return count
return inc
foo = counter()
print(foo(),foo())
1 2
count是外层函数的局部变量,被内部函数引用
内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义。
代码中内层函数引用外部局部作用域中的自由变量,形成闭包。
def foo(xyz=1):
print(xyz)
foo()
1
-------------------------
print(foo())
1
None
--------------------------
def foo(xyz=[]):
xyz.append(1)
print(xyz)
foo()
[1]
-------------------------------
foo()
[1,1]
-------------------------------
print(xyz)
NameError: name 'xyz' is not defined
-------------------------------
print(foo())
[1, 1, 1, 1]
None
- 每个函数定义被执行后,就生成了一个函数对象和函数名这个标识符关联
- python把函数的模拟任职放在了函数对象的属性中,这个属性就伴随这个函数对象的整个生命周期
- 查看foo._default_属性,它是个元祖
def foo(xyz=[],m = 123,n = 'abc'):
xyz.append(1)
print(xyz)
print(id(foo),foo.__defaults__)
140727444481840 ([], 123, 'abc')
-------------------------------------
foo()
[1]
--------------------------------------
print(id(foo),foo.__defaults__)
140727444481840 ([1], 123, 'abc')
函数地址并没有变,就是说foo这个函数对象的没有变过,调用它,它的属性__defaults__中使用元祖默认值,xyz默认值的引用类型,引用类型的元素变动,并不是元祖的变化
def foo(xyz,m = 123,n = 'abc'):
m = 455
n = 'A'
print(xyz)
print(foo.__defaults__)
(123, 'abc')
-------------------------
foo('heihei')
heihei
-------------------------
print(foo.__defaults__)
(123, 'abc')
属性__defaults__中使用元祖保存所有位置参数默认值,它不会因为函数体内改变了局部变量(形参)的值而发生改变
def foo(xyz,m = 123,*,n = 'abc',t = [1,2]):
m = 455
n = 'A'
t.append(300)
print(xyz,m,n,t)
------------------------------------
print(foo.__defaults__,foo.__kwdefaults__)
(123,) {'n': 'abc', 't': [1, 2]}
------------------------------------------
foo('heihei')
heihei 455 A [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__)
([5, 5],)
def x(a=[]):
a = a + [5]
print(x.__defaults__)
([],)
x()
x()
print(x.__defaults__)
([],)
- +表示两个列表合并并返回一个全新的列表
- +=表示,就地修改前一个列表,在其后追加后一个列表,就是extend方法
变量名解析原则LEGB
- local,本地作用域,局部作用域的local命名空间。函数调用时创建,电泳结束消亡
- Enclosing,python2.2时引入了嵌套函数,实现了闭包,这个就是嵌套函数的外部函数的命名空间
- Global,全局作用域,即一个模块的命名空间。模块被import时创建,解释器退出时消亡
- Build-in,内置模块的命名空间,生命周期从python解释器启动时创建到解释器退出时消亡。例如print(open),prin和open都是内置的变量
所以一个名次的查找顺序就是LEGB
函数的销毁
- 定义一个函数就是生成一个函数对象,函数名指向的就是函数对象
- 可以使用del语句删除函数,使其引用计数减1
- 可以使用同名标识符覆盖原有定义,本质上也是使其引用计数减1
- Python程序结束时,所有对象销毁
- 函数也是对象,也不例外,是否销毁,还是看引用计数是否减为0