函数的返回值和作用域
1、返回值
def guess(x):
if x > 3:
return "> 3"
else:
return "<= 3"
print(guess(10))
1> Python 函数使用 return 语句返回 "返回值”
2> 所有函数都有返回值,如果没有 return 语句,隐式调用 return None
3> return 语句并不一定是函数的语句块的最后一条语句
4> 一个函数可以存在多个 return 语句,但是只有一条可以被执行。如果没有一条 return 语句被执行到,隐式调用 return None
5> 如果有必要,可以显示调用return None,可以简写为return
6> 如果函数执行了 return 语句,函数就会返回,当前被执行的 return 语句之后的其它语句就不会被执行了
7> 返回值的作用:结束函数调用、返回 "返回值”
2、能一次返回多个值嘛?
defshowvalues():return 1, 3, 5
print(showvalues()) #返回 (1, 3, 5)
函数不能同时返回多个值
return 1, 3, 5 看似返回多个值,隐式的被 python 封装成了一个元组
x, y, z = showvalues() 使用解构提取返回值更为方便
3、函数作用域**
3.1 作用域
一个标识符的可见范围,这就是标识符的作用域,一般常说变量的作用域。
x = 20
deffn():
x= 100 #x 的作用域:当前函数
fn()print(x) #x = 20
注意:每一个函数都会开辟一个作用域。
3.2 作用域分类
全局作用域:
在整个程序运行环境中都可见
全局作用域中的变量称为全局变量
局部作用域:
在函数、类等内部可见
局部作用域中的变量称为局部变量,其使用范围不超过其所在局部作用域
#局部变量
deffn1():
x= 1 #局部作用域,x 为局部变量,使用范围在 fn1 内
deffn2():print(x) #x 能打印吗?不能
print(x) #x 能打印吗?不能
#全局变量
x = 5 #全局变量,也在函数外定义
deffoo():print(x) #可见吗?可以
foo()
一般来讲外部作用域变量在函数内部可见,可以使用
反过来,函数内部的局部变量,不能在函数外部看到
4、函数嵌套
在一个函数中定义另一个函数
defouter():definner():print('inner')print('outer')
inner()
outer()
inner()#不可以
内部函数 inner 不能在外部直接使用,会抛出 NameError 异常,因为它在函数外部不可见。
其实,inner 不过就是一个标识符,就是一个函数 outer 内部定义的变量而已。
5、嵌套函数的作用域
defouter():
o= 65 #局部变量、本地 local 变量、临时变量
definner():
o= 97
print('inner', o)print('outer 1', o)
inner()print('outer 2', o)
outer()#1:outer 1 65 2:inner 97 3:outer 2 65
外层变量在内部作用域可见。
内层作用域中,如果定义了和外层相同的变量,相当于在当前函数作用域中重新定义了一个新的变量,这个内层变量并不能覆盖掉外部作用域中的变量。
6、一个赋值语句的问题
x = 100
deffn():
y= x + 200
print(y)
fn()
x = 100
deffn():
x+= 1 #报错! 赋值即定义,即 x = x + 1 (局部变量 = 局部变量 + 1)!
print(x)
fn()
x = 100
deffn():print(x) #报错!该步执行不了!
x += 1 #只要在该作用域内赋值定义('=')局部变量,在该作用域内的所有该变量都为局部变量!
print(x)
fn()
能否解决呢?可以,使用 global 语句
x = 100
deffn():global x #声明全局变量
print(x) #100
x += 1
print(x) #101
fn()print(x) #101
注意:全局变量一般情况不推荐修改,一旦在作用域中使用 global 声明全局变量,那么相当于在对全局变量赋值、定义。
global 使用原则:
1> 外部作用域变量会在内部作用域可见,但也不要在这个内部的局部作用域中直接使用,因为函数的目的就是为了封装,尽量与外界隔离。
2> 如果函数需要使用外部全局变量,请尽量使用函数的形参定义,并在调用传实参解决。
3> 一句话:不用 global,学习它就是为了深入理解变量作用域。
#不建议直接传入全局变量!
y =[]def foo(): #x 就是标识符,就是变量,就是本地变量
y.append(1)
foo()
foo()print(y)
#建议使用传参的方式,在函数内使用全局变量
y =[]def foo(x): #x 就是标识符,就是变量,就是本地变量
x.append(1)
foo(y)
foo(y)print(y)
7、闭包**
自由变量:未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量。
闭包:就是一个概念,出现在嵌套函数中,指的是内层函数引用到了外层函数的自由变量,就形成了闭包。很多语言都有这个概念,最熟悉就是 JavaScript。
#python 2 实现闭包
defcounter():
c=[0]definc():
c[0]+= 1 #是赋值即定义嘛?不是!是修改值
returnc[0]return inc #返回标识符,即函数对象
m=counter()
m()#调用函数 inc(),但是 c 消亡了嘛?没有,内层函数没有消亡,c 不消亡(闭包)
m()
m()print(m())
#不推荐使用 global !
defcounter():globalc
c=0definc():globalc
c+= 1 #不是闭包!
returncreturninc
m=counter()
m()
m()
m()print(m())
#推荐使用 nonlocal,python 3 实现闭包
defcounter():
c=0definc():
nonlocal c#非当前函数的本地变量,当前函数之外的任意层函数的变量,绝非 global
c += 1 #是闭包吗?是!
returncreturninc
m=counter()
m()
m()
m()print(m())
nonlocal 语句:将变量标记为不在本地作用域定义,而是在上级的某一级局部作用域中定义,但不能是全局作用域中。
8、默认值的作用域
def foo(x=1):
x+= 1
print(x)
foo()#2
foo() #2
def bar(x=[]): #x = [],引用类型
x.append(1) #[1]
print(x)
bar()#[1]
bar() #[1, 1]
为什么上列 bar 函数第二次调用打印的是 [1, 1]?
因为函数也是对象,每个函数定义被执行后,就生成了一个函数对象和函数名这个标识符关联。
python 把函数的默认值放在了函数对象的属性中,这个属性就伴随着这个函数对象的整个生命周期。
#查看 foo.__defaults__ 属性,它是个元组
def bar(x=[]):
x.append(1)print(x)print(bar.__defaults__)
bar()#[1]
print(bar.__defaults__)
bar()#[1, 1]
print(bar.__defaults__)#执行结果:
([],)
[1]
([1],)
[1, 1]
([1, 1],) #元组不变,记录的是地址,引用类型变化
def foo(x, m=123, n='abc'):
m=456n='def'
print(x)print(foo.__defaults__) #(123, 'abc')
foo('yang')print(foo.__defaults__) #(123, 'abc')
def foo(x, m=123, *, n='abc', t=[1,2]):
m=456n='def't.append(12)#t[:].append(12) # t[:],全新复制一个列表,避免引用计数
print(x, m, n, t)print(foo.__defaults__, foo.__kwdefaults__) #(123,) {'n': 'abc', 't': [1, 2]}
foo('yang')print(foo.__defaults__, foo.__kwdefaults__) #(123,) {'n': 'abc', 't': [1, 2, 12]}
def x(a=[]):
a= a + [5] #加法的本质:返回新列表、新地址;赋值即定义
print(x.__defaults__) #([],)
x()
x()print(x.__defaults__) #([],)
def y(a=[]):
a+= [5] #+= 即 extend => a.extend([5])
print(y.__defaults__) #([],)
y()
y()print(y.__defaults__) #([5, 5],)
#列表的 + 和 += 的区别:#+ 表示两个列表合并并返回一个全新的列表。#+= 表示,就地修改前一个列表,在其后追加后一个列表,就是 extend 方法。#例:
l1 = [1, 2]
l2= [3, 4]
l3= l1 +l2print(id(l1), id(l2), id(l3))
l3+= l2 #就地修改
print(id(l3))
执行结果:2279905055304 2279905055816 2279906334216
2279906334216
9、变量名解析原则 LEGB**
Local,本地作用域、局部作用域的 local 命名空间,函数调用时创建,调用结束消亡。
Enclosing,Python2.2 时引入了 嵌套函数,实现了闭包,这个就是嵌套函数的外部函数的命名空间。
Global,全局作用域,即一个模块的命名空间。模块被 import 时创建, 解释器退出时消亡。
Build-in,内置模块的命名空间,生命周期从 python 解释器启动时创建到解释器退出时消亡。例如 print(open),print 和 open 都是内置的变量。
所以一个名词的查找顺序就是 LEGB
10、函数的销毁
定义一个函数就是生成一个函数对象,函数名指向的就是函数对象。
可以使用del语句删除函数,使其引用计数减 1。
可以使用同名标识符覆盖原有定义,本质上也是使其引用计数减 1。
Python程序结束时,所有对象销毁。
函数也是对象,也不例外,是否销毁,还是看引用计数是否减为 0。