离线下载
PDF版 ePub版

老齐 · 更新于 2018-11-28 11:00:43

函数(3)

在设计函数的时候,有时候我们能够确认参数的个数,比如一个用来计算圆面积的函数,它所需要的参数就是半径(πr^2),这个函数的参数是确定的。

你能不能写一个能够计算圆面积的函数呢?

然而,这个世界不总是这么简单的,也不总是这么确定的,反而不确定性是这个世界常常存在的。如果看官了解量子力学——好多人听都没有听过的东西——就更理解真正的不确定性了。当然,不用研究量子力学也一样能够体会到,世界充满里了不确定性。不是吗?塞翁失马焉知非福,这不就是不确定性吗?

参数收集

既然有很多不确定性,那么函数的参数的个数,也当然有不确定性,函数怎么解决这个问题呢?Python 用这样的方式解决参数个数的不确定性:

def func(x,*arg):
    print x         #输出参数 x 的值
    result = x
    print arg       #输出通过 *arg 方式得到的值
    for i in arg:
        result +=i
    return result

print func(1,2,3,4,5,6,7,8,9)    #赋给函数的参数个数不仅仅是  2个

运行此代码后,得到如下结果:

1                       #这是函数体内的第一个 print,参数x得到的值是 1
(2, 3, 4, 5, 6, 7, 8, 9) #这是函数内的第二个 print,参数 arg 得到的是一个元组
45                      #最后的计算结果

从上面例子可以看出,如果输入的参数个数不确定,其它参数全部通过 *arg,以元组的形式由 arg 收集起来。对照上面的例子不难发现:

  • 值 1 传给了参数 x
  • 值 2,3,4,5,6.7.8.9 被塞入一个 tuple 里面,传给了 arg

为了能够更明显地看出 args(名称可以不一样,但是 符号必须要有),可以用下面的一个简单函数来演示:

>>> def foo(*args):
...     print args      #打印通过这个参数得到的对象
... 

下面演示分别传入不同的值,通过参数 *args 得到的结果:

>>> foo(1,2,3)
(1, 2, 3)

>>> foo("qiwsir","qiwsir.github.io","python")
('qiwsir', 'qiwsir.github.io', 'python')

>>> foo("qiwsir",307,["qiwsir",2],{"name":"qiwsir","lang":"python"})
('qiwsir', 307, ['qiwsir', 2], {'lang': 'python', 'name': 'qiwsir'})

不管是什么,都一股脑地塞进了 tuple 中。

>>> foo("python")
('python',)

即使只有一个值,也是用 tuple 收集它。特别注意,在 tuple 中,如果只有一个元素,后面要有一个逗号。

还有一种可能,就是不给那个 *args 传值,也是许可的。例如:

>>> def foo(x, *args):
...     print "x:",x
...     print "tuple:",args
... 
>>> foo(7)
x: 7
tuple: ()

这时候 *args 收集到的是一个空的 tuple。

在各类编程语言中,常常会遇到以 foo,bar,foobar 等之类的命名,不管是对变量、函数还是后面要讲到的类。这是什么意思呢?下面是来自维基百科的解释。

在计算机程序设计与计算机技术的相关文档中,术语 foobar 是一个常见的无名氏化名,常被作为“伪变量”使用。

从技术上讲,“foobar”很可能在 1960 年代至 1970 年代初通过迪吉多的系统手册传播开来。另一种说法是,“foobar”可能来源于电子学中反转的 foo 信号;这是因为如果一个数字信号是低电平有效(即负压或零电压代表“1”),那么在信号标记上方一般会标有一根水平横线,而横线的英文即为“bar”。在《新黑客辞典》中,还提到“foo”可能早于“FUBAR”出现。

单词“foobar”或分离的“foo”与“bar”常出现于程序设计的案例中,如同 Hello World 程序一样,它们常被用于向学习者介绍某种程序语言。“foo”常被作为函数/方法的名称,而“bar”则常被用作变量名。

除了用 *args 这种形式的参数接收多个值之外,还可以用 **kargs 的形式接收数值,不过这次有点不一样:

>>> def foo(**kargs):
...     print kargs
...
>>> foo(a=1,b=2,c=3)    #注意观察这次赋值的方式和打印的结果
{'a': 1, 'c': 3, 'b': 2}

如果这次还用 foo(1,2,3)的方式,会有什么结果呢?

>>> foo(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 0 arguments (3 given)

如果用 **kargs 的形式收集值,会得到 dict 类型的数据,但是,需要在传值的时候说明“键”和“值”,因为在字典中是以键值对形式出现的。

看官到这里可能想了,不是不确定性吗?我也不知道参数到底会可能用什么样的方式传值呀,这好办,把上面的都综合起来。

>>> def foo(x,y,z,*args,**kargs):
...     print x   
...     print y
...     print z
...     print args
...     print kargs        
... 
>>> foo('qiwsir',2,"python")
qiwsir
2
python
()
{}
>>> foo(1,2,3,4,5)
1
2
3
(4, 5)
{}
>>> foo(1,2,3,4,5,name="qiwsir")
1
2
3
(4, 5)
{'name': 'qiwsir'}

很 good 了,这样就能够足以应付各种各样的参数要求了。

另外一种传值方式

>>> def add(x,y):
...     return x + y
... 
>>> add(2,3)
5

这是通常的函数调用方法,在前面已经屡次用到。这种方法简单明快,很容易理解。但是,世界总是多样性的,有时候你秀出下面的方式,甚至在某种情况用下面的方法可能更优雅。

>>> bars = (2,3)
>>> add(*bars)
5

先把要传的值放到元组中,赋值给一个变量 bars,然后用 add(*bars) 的方式,把值传到函数内。这有点像前面收集参数的逆过程。注意的是,元组中元素的个数,要跟函数所要求的变量个数一致。如果这样:

>>> bars = (2,3,4)
>>> add(*bars)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes exactly 2 arguments (3 given)

就报错了。

这是使用一个星号 *,是以元组形式传值,如果用 ** 的方式,是不是应该以字典的形式呢?理当如此。

>>> def book(author,name):
...     print "%s is writing %s" % (author,name)
... 
>>> bars = {"name":"Starter learning Python","author":"Kivi"}
>>> book(**bars)
Kivi is writing Starter learning Python

这种调用函数传值的方式,至少在我的编程实践中,用的不多。不过,不代表读者不用。这或许是习惯问题。

复习

python 中函数的参数通过赋值的方式来传递引用对象。下面总结通过总结常见的函数参数定义方式,来理解参数传递的流程。

def foo(p1,p2,p3,...)

这种方式最常见了,列出有限个数的参数,并且彼此之间用逗号隔开。在调用函数的时候,按照顺序以此对参数进行赋值,特备注意的是,参数的名字不重要,重要的是位置。而且,必须数量一致,一一对应。第一个对象(可能是数值、字符串等等)对应第一个参数,第二个对应第二个参数,如此对应,不得偏左也不得偏右。

>>> def foo(p1,p2,p3):
...     print "p1==>",p1
...     print "p2==>",p2
...     print "p3==>",p3
... 
>>> foo("python",1,["qiwsir","github","io"])    #一一对应地赋值
p1==> python
p2==> 1
p3==> ['qiwsir', 'github', 'io']

>>> foo("python")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 3 arguments (1 given)    #注意看报错信息

>>> foo("python",1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 3 arguments (4 given)    #要求 3 个参数,实际上放置了 4 个,报错

def foo(p1=value1,p2=value2,...)

这种方式比前面一种更明确某个参数的赋值,貌似这样就不乱子了,很明确呀。颇有一个萝卜对着一个坑的意味。

还是上面那个函数,用下面的方式赋值,就不用担心顺序问题了。

>>> foo(p3=3,p1=10,p2=222)
p1==> 10
p2==> 222
p3==> 3

也可以采用下面的方式定义参数,给某些参数有默认的值

>>> def foo(p1,p2=22,p3=33):    #设置了两个参数 p2,p3 的默认值
...     print "p1==>",p1
...     print "p2==>",p2
...     print "p3==>",p3
... 
>>> foo(11)     #p1=11,其它的参数为默认赋值
p1==> 11
p2==> 22
p3==> 33
>>> foo(11,222)     #按照顺序,p2=222,p3 依旧维持原默认值
p1==> 11
p2==> 222
p3==> 33
>>> foo(11,222,333)  #按顺序赋值
p1==> 11
p2==> 222
p3==> 333

>>> foo(11,p2=122)
p1==> 11
p2==> 122
p3==> 33

>>> foo(p2=122)     #p1 没有默认值,必须要赋值的,否则报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes at least 1 argument (1 given)

def foo(*args)

这种方式适合于不确定参数个数的时候,在参数 args 前面加一个 *,注意,仅一个哟。

>>> def foo(*args):         #接收不确定个数的数据对象
...     print args
... 
>>> foo("qiwsir.github.io") #以 tuple 形式接收到,哪怕是一个
('qiwsir.github.io',)
>>> foo("qiwsir.github.io","python")
('qiwsir.github.io', 'python')

def foo(**args)

这种方式跟上面的区别在于,必须接收类似 arg=val 形式的。

>>> def foo(**args):    #这种方式接收,以 dictionary 的形式接收数据对象
...     print args
... 

>>> foo(1,2,3)          #这样就报错了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 0 arguments (3 given)

>>> foo(a=1,b=2,c=3)    #这样就可以了,因为有了键值对
{'a': 1, 'c': 3, 'b': 2}

下面来一个综合的,看看以上四种参数传递方法的执行顺序

>>> def foo(x,y=2,*targs,**dargs):
...     print "x==>",x
...     print "y==>",y
...     print "targs_tuple==>",targs
...     print "dargs_dict==>",dargs
... 

>>> foo("1x")
x==> 1x
y==> 2
targs_tuple==> ()
dargs_dict==> {}

>>> foo("1x","2y")
x==> 1x
y==> 2y
targs_tuple==> ()
dargs_dict==> {}

>>> foo("1x","2y","3t1","3t2")
x==> 1x
y==> 2y
targs_tuple==> ('3t1', '3t2')
dargs_dict==> {}

>>> foo("1x","2y","3t1","3t2",d1="4d1",d2="4d2")
x==> 1x
y==> 2y
targs_tuple==> ('3t1', '3t2')
dargs_dict==> {'d2': '4d2', 'd1': '4d1'}

总目录   |   上节:函数(2)   |   下节:函数(4)

如果你认为有必要打赏我,请通过支付宝:qiwsir@126.com,不胜感激。

上一篇: 函数(2) 下一篇: 函数(4)