python中参数问题

￡神魔★判官ぃ 2022-07-30 13:52 237阅读 0赞

函数部分参数的"\*"与"\*\*"，闭包等问题，着实令人迷糊了一把，弄清概念后写下此文记录下来,也希望本文能够帮助其他初学者。

所以本文是一篇学习笔记，着重于使用的细节和理解上，首先分别介绍了函数各种参数类型在调用和声明时的区别，及其在混用时需要注意的一些细节，之后讲了闭包相关的内容。如果有不对的地方欢迎指正。

# 函数参数"\*"与 "\*\*"的区别 #

理解这个问题得关键在于要分开理解调用和声明语法中3者的区别.

## **函数调用区别** ##

### **1. 不同类型的参数简述** ###

\#这里先说明python函数调用得语法为：

复制代码代码如下:

func(positional\_args, keyword\_args,  
\*tuple\_grp\_nonkw\_args, \*\*dict\_grp\_kw\_args)  
  
\#为了方便说明,之后用以下函数进行举例  
def test(a,b,c,d,e):  
print a,b,c,d,e

举个例子来说明这4种调用方式得区别：

复制代码代码如下:

\#-------------------------------  
\# **positional\_args方式**  
>>> test(1,2,3,4,5)  
1 2 3 4 5

\#这种调用方式的函数处理等价于  
a,b,c,d,e = 1,2,3,4,5  
print a,b,c,d,e

\#-------------------------------  
\#**keyword\_args方式**  
>>> test(a=1,b=3,c=4,d=2,e=1)  
1 3 4 2 1

\#这种处理方式得函数处理等价于  
a=1  
b=3  
c=4  
d=2  
e=1  
print a,b,c,d,e

\#-------------------------------  
\#**\*tuple\_grp\_nonkw\_args方式**  
>>> x = 1,2,3,4,5  
>>> test(\*x)  
1 2 3 4 5

\#这种方式函数处理等价于  
a,b,c,d,e = x  
print a,b,c,d,e  
\#特别说明:x也可以为dict类型,x为dick类型时将键传递给函数  
>>> y  
\{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1\}  
>>> test(\*y)  
a c b e d

\#---------------------------------  
\#**\*\*dict\_grp\_kw\_args方式**  
>>> y  
\{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1\}  
>>> test(\*\*y)  
1 2 6 1 1

\#这种函数处理方式等价于  
a = y\['a'\]  
b = y\['b'\]  
... \#c,d,e不再赘述  
print a,b,c,d,e

### **2. 不同类型参数混用需要注意的一些细节** ###

接下来说明不同参数类型混用的情况,要理解不同参数混用得语法需要理解以下几方面内容.

首先要明白,函数调用使用参数类型必须**严格按照顺序**,不能随意调换顺序,否则会报错. 如 (a=1,2,3,4,5)会引发错误,; (\*x,2,3)也会被当成非法.

其次,函数对不同方式处理的顺序也是按照上述的类型顺序.因为\#keyword\_args方式和\*\*dict\_grp\_kw\_args方式对参数一一指定,所以无所谓顺序.所以只需要考虑顺序赋值(positional\_args)和列表赋值(\*tuple\_grp\_nonkw\_args)的顺序.因此,可以简单理解为**只有\#positional\_args方式,\#\*tuple\_grp\_nonkw\_args方式有逻辑先后顺序**的.

最后,参数是**不允许多次赋值**的.

举个例子说明,顺序赋值(positional\_args)和列表赋值(\*tuple\_grp\_nonkw\_args)的逻辑先后关系:

复制代码代码如下:

\#只有在顺序赋值,列表赋值在结果上存在罗辑先后关系  
\#正确的例子1  
>>> x = \{3,4,5\}  
>>> test(1,2,\*x)  
1 2 3 4 5  
\#正确的例子2  
>>> test(1,e=2,\*x)  
1 3 4 5 2

\#错误的例子  
>>> test(1,b=2,\*x)  
Traceback (most recent call last):  
File "<stdin>", line 1, in <module>  
TypeError: test() got multiple values for keyword argument 'b'

\#正确的例子1,处理等价于  
a,b = 1,2 \#顺序参数  
c,d,e = x \#列表参数  
print a,b,c,d,e

\#正确的例子2,处理等价于  
a = 1 \#顺序参数  
e = 2 \#关键字参数  
b,c,d = x \#列表参数

\#错误的例子,处理等价于  
a = 1 \#顺序参数  
b = 2 \#关键字参数  
b,c,d = x \#列表参数  
\#这里由于b多次赋值导致异常,可见只有顺序参数和列表参数存在罗辑先后关系

## **函数声明区别** ##

理解了函数调用中不同类型参数得区别之后,再来理解函数声明中不同参数得区别就简单很多了.

### **1. 函数声明中的参数类型说明** ###

函数声明只有3种类型, arg, \*arg , \*\*arg 他们得作用和函数调用刚好相反. 调用时\*tuple\_grp\_nonkw\_args将列表转换为顺序参数,而声明中的\*arg的作用是将顺序赋值(positional\_args)转换为列表. 调用时\*\*dict\_grp\_kw\_args将字典转换为关键字参数,而声明中\*\*arg则反过来将关键字参数(keyword\_args)转换为字典.  
**特别提醒：\*arg 和 \*\*arg可以为空值.**

以下举例说明上述规则:

复制代码代码如下:

\#arg, \*arg和\*\*arg作用举例  
def test2(a,\*b,\*\*c):  
print a,b,c  
\#---------------------------  
\#\*arg 和 \*\*arg可以不传递参数  
>>> test2(1)  
1 () \{\}  
\#arg必须传递参数  
>>> test2()  
Traceback (most recent call last):  
File "<stdin>", line 1, in <module>  
TypeError: test2() takes at least 1 argument (0 given)

\#----------------------------  
\#\*arg将顺positional\_args转换为列表  
>>> test2(1,2,\[1,2\],\{'a':1,'b':2\})  
1 (2, \[1, 2\], \{'a': 1, 'b': 2\}) \{\}  
\#该处理等价于  
a = 1 \#arg参数处理  
b = 2,\[1,2\],\{'a':1,'b':2\} \#\*arg参数处理  
c = dict() \#\*\*arg参数处理  
print a,b,c

\#-----------------------------  
\#\*\*arg将keyword\_args转换为字典  
>>> test2(1,2,3,d=\{1:2,3:4\}, c=12, b=1)  
1 (2, 3) \{'c': 12, 'b': 1, 'd': \{1: 2, 3: 4\}\}  
\#该处理等价于  
a = 1 \#arg参数处理  
b= 2,3 \#\*arg参数处理  
\#\*\*arg参数处理  
c = dict()  
c\['d'\] = \{1:2, 3:4\}  
c\['c'\] = 12  
c\['b'\] = 1  
print a,b,c

### 2. 处理顺序问题 ###

函数总是**先处理arg类型参数,再处理\*arg和\*\*arg类型的参数**. 因为\*arg和\*\*arg针对的调用参数类型不同,所以不需要考虑他们得顺序.

复制代码代码如下:

def test2(a,\*b,\*\*c):  
print a,b,c  
>>> test2(1, b=\[1,2,3\], c=\{1:2, 3:4\},a=1)  
Traceback (most recent call last):  
File "<stdin>", line 1, in <module>  
TypeError: test2() got multiple values for keyword argument 'a'  
\#这里会报错得原因是,总是先处理arg类型得参数  
\#该函数调用等价于  
\#处理arg类型参数:  
a = 1  
a = 1 \#多次赋值,导致异常  
\#处理其他类型参数  
...  
print a,b,c

## 闭包 ##

python的函数,原本只能访问两个区域的变量:全局,和局部(函数上下文). 实际上,函数本身也是一个对象,也有自己的作用域. 闭包通过函数与引用集合的组合,使得函数可以在它被定义的区域之外执行. 这个集合可以通过func\_closure来获取这个引用集合. 这与python处理全局变量得方式一样,只不过全局变量将引用集合存储在\_\_globals\_\_字段中.func\_closure是一个存储cell类型的元组,每个cell存储一个上下文变量.

另外,旧版本得python的内部函数不能在其他作用域使用的原因,并不是因为每个作用域的变量严格相互隔离,而是脱离原本的作用域后,函数失去了原本上下文的引用。需要注意的是，闭包存储的上下文信息一样是浅拷贝,所以传递给内部函数的可变对象仍然会被其他拥有该对象引用得变量修改.

举个例子:

代码如下:

>>> def foo(x,y):  
... def bar():  
... print x,y  
... return bar  
...  
\#查看func\_closure的引用信息  
>>> a = \[1,2\]  
>>> b = foo(a,0)  
>>> b.func\_closure\[0\].cell\_contents  
\[1, 2\]  
>>> b.func\_closure\[1\].cell\_contents  
0  
>>> b()  
\[1, 2\] 0

\#可变对象仍然能被修改  
>>> a.append(3)  
>>> b.func\_closure\[0\].cell\_contents  
\[1, 2, 3\]  
>>> b()  
\[1, 2, 3\] 0

### **1. 闭包的概念** ###

首先还得从基本概念说起，什么是闭包呢？来看下维基上的解释:

复制代码代码如下:

在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。  
....

上面提到了两个关键的地方： 自由变量 和 函数, 这两个关键稍后再说。还是得在赘述下“闭包”的意思，望文知意，可以形象的把它理解为一个封闭的包裹，这个包裹就是一个函数，当然还有函数内部对应的逻辑，包裹里面的东西就是自由变量，自由变量可以在随着包裹到处游荡。当然还得有个前提，这个包裹是被创建出来的。

在通过Python的语言介绍一下，一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。

举个例子：

复制代码代码如下:

def func(name):  
def inner\_func(age):  
print 'name:', name, 'age:', age  
return inner\_func

bb = func('the5fire')  
bb(26) \# >>> name: the5fire age: 26

这里面调用func的时候就产生了一个闭包——inner\_func,并且该闭包持有自由变量——name，因此这也意味着，当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收。

另外再说一点，闭包并不是Python中特有的概念，所有把函数做为一等公民的语言均有闭包的概念。不过像Java这样以class为一等公民的语言中也可以使用闭包，只是它得用类或接口来实现。

更多概念上的东西可以参考最后的参考链接。

### **2. 为什么使用闭包** ###

基于上面的介绍，不知道读者有没有感觉这个东西和类有点相似，相似点在于他们都提供了对数据的封装。不同的是闭包本身就是个方法。和类一样，我们在编程时经常会把通用的东西抽象成类，（当然，还有对现实世界——业务的建模），以复用通用的功能。闭包也是一样，当我们需要函数粒度的抽象时，闭包就是一个很好的选择。

在这点上闭包可以被理解为一个只读的对象，你可以给他传递一个属性，但它只能提供给你一个执行的接口。因此在程序中我们经常需要这样的一个函数对象——闭包，来帮我们完成一个通用的功能，比如后面会提到的——装饰器。

### **3. 使用闭包** ###

第一种场景 ，在python中很重要也很常见的一个使用场景就是装饰器，Python为装饰器提供了一个很友好的“语法糖”——@，让我们可以很方便的使用装饰器，装饰的原理不做过多阐述，简言之你在一个函数func上加上@decorator\_func, 就相当于decorator\_func(func):

复制代码代码如下:

def decorator\_func(func):  
def wrapper(\*args, \*\*kwargs):  
return func(\*args, \*\*kwargs)  
return wrapper

@decorator\_func  
def func(name):  
print 'my name is', name

\# 等价于  
decorator\_func(func)

在装饰器的这个例子中，闭包（wrapper）持有了外部的func这个参数，并且能够接受外部传过来的参数，接受过来的参数在原封不动的传给func，并返回执行结果。

这是个简单的例子，稍微复杂点可以有多个闭包，比如经常使用的那个LRUCache的装饰器，装饰器上可以接受参数@lru\_cache(expire=500)这样。实现起来就是两个闭包的嵌套:

复制代码代码如下:

def lru\_cache(expire=5):  
\# 默认5s超时  
def func\_wrapper(func):  
def inner(\*args, \*\*kwargs):  
\# cache 处理 bala bala bala  
return func(\*args, \*\*kwargs)  
return inner  
return func\_wrapper

@lru\_cache(expire=10\*60)  
def get(request, pk)  
\# 省略具体代码  
return response()

不太懂闭包的同学一定得能够理解上述代码，这是我们之前面试经常会问到的面试题。  
第二个场景 ，就是基于闭包的一个特性——“惰性求值”。这个应用比较常见的是在数据库访问的时候，比如说：

复制代码代码如下:

\# 伪代码示意

class QuerySet(object):  
def \_\_init\_\_(self, sql):  
self.sql = sql  
self.db = Mysql.connect().corsor() \# 伪代码

def \_\_call\_\_(self):  
return db.execute(self.sql)

def query(sql):  
return QuerySet(sql)

result = query("select name from user\_app")  
if time > now:  
print result \# 这时才执行数据库访问

上面这个不太恰当的例子展示了通过闭包完成惰性求值的功能，但是上面query返回的结果并不是函数，而是具有函数功能的类。有兴趣的可以去看看Django的queryset的实现，原理类似。

第三种场景 ， 需要对某个函数的参数提前赋值的情况，当然在Python中已经有了很好的解决访问 functools.parial,但是用闭包也能实现。

复制代码代码如下:

def partial(\*\*outer\_kwargs):  
def wrapper(func):  
def inner(\*args, \*\*kwargs):  
for k, v in outer\_kwargs.items():  
kwargs\[k\] = v  
return func(\*args, \*\*kwargs)  
return inner  
return wrapper

@partial(age=15)  
def say(name=None, age=None):  
print name, age

say(name="the5fire")  
\# 当然用functools比这个简单多了  
\# 只需要： functools.partial(say, age=15)(name='the5fire')

看起来这又是一个牵强的例子，不过也算是实践了闭包的应用。