Python函数（二）

最新推荐文章于 2023-03-06 18:58:43 发布

FatTigerx

最新推荐文章于 2023-03-06 18:58:43 发布

阅读量359

点赞数

本文链接：https://blog.csdn.net/FatTigerx/article/details/89294616

版权

函数返回值

#####此篇文章来源于我的老师Wayne,仅作记录以备复习
先看几个例子

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(2))
------------------------
下面函数执行的结果是什么
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))

总结

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 = showvalues() 使用解构提取返回值更为方便，之后 print(x,y,z)

函数作用域***

作用域

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

def foo():
    x = 100

print(x)    可以访问到吗

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

作用域分类

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

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

def fn2():
	print(x)   x 能打印么？可见么？为什么？
	
print(x)   x能打印么？可见吗？为什么？

全局变量
x = 5     全局变量，也在函数外定义
def foo():
    print(x)	可见么？为什么？

foo()

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

函数嵌套

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

def outer():
	def inner():
		print("inner")
	print("outer")
	inner()
outer()		可以么
inner()		可以么

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

嵌套结构的作用域

对比下面嵌套结构，代码执行的效果

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

outer1()   执行后，打印什么？

inner65
outer65

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

outer2()   执行后，打印什么？

inner97
a
outer65

从执行结果来看：

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

一个赋值语句的问题

再看下例
在这里插入图片描述
仔细观察函数2返回的错误指向 x += 1，原因是什么呢？

x = 5
def foo():
	x += 1
foo()   #报错如下

在这里插入图片描述原因分析：

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 定义会怎样？

注意，下面试验如果在 Ipython、jupyter 中做，上下文运行环境中有可能有 x 的定义，稍微不注意，就测试不出效果

有错么？
def foo():
    global x
    x += 1
    print(x)
foo()

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 = 10 相当于在为全局作用域的变量x 赋值

global使用原则

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

闭包***

自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量
闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉就是JavaScript

1  def counter():
2      c = [0]
3      def inc():
4          c[0] += 1
5          return c[0]
6      return inc
7  foo = counter()
8  print(foo(),foo())
9  c = 100
10 print(foo())

上面代码有几个问题：

第4行会报错吗？为什么
第8行打印什么结果？
第10行打印什么结果？

代码分析

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

来自python doc的本地/全局/自由变量定义：

If a name is bound in a block, it is a local variable of that block, unless declared as nonlocal. If a name is bound at the module level, it is a global variable. (The variables of the module code block are local and global.) If a variable is used in a code block but not defined there, it is a free variable.

这是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())

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

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 += 1
        return count
    return inc
    
foo = counter()
foo()
foo()

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

默认值的作用域

def foo(xyz=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__)

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

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

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

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

属性__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__)

只有一句不同，却输出结果不同？
这就要说道列表的 + 和 += 的区别：

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

变量名解析原则LEGB ***

Local , 本地作用域、局部作用域的 local 命名空间。函数调用时创建，调用结束消亡
Enclosing , Python 2.2 时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间
Global , 全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡
Bulid-in , 内置模块的命名空间，生命周期从python解释器启动时创建到解释器退出时消亡。例如 print(open),print 和 open 都是内置的变量

所以一个名词的查找顺序就是LEGB
在这里插入图片描述

函数的销毁

定义一个函数就是生成一个函数对象，函数名指向的就是函数对象。
可以使用 del 语句删除函数，使其引用计数减1。
可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减1.
Python程序结束时，所有对象销毁。
函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0。

FatTigerx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python函数（二）

函数返回值先看几个例子return语句之后可以执行么？def showplus(x): print(x) return x + 1 print('~~end~~') return语句之后可以执行么？ showplus(5)------------------------多条return语句都会执行么？def showplus(x): pri...
复制链接

扫一扫