参数类型

阅读: 4108


绝大多数函数接收一定数量的参数,然后根据实际调用时提供的参数的值的不同,输出不同的结果。前面我们说过,将函数内部的参数名字,定义得和外部变量的名字一样是一种不好的习惯,它容易混淆思维,甚至发生错误。通常我们定义和给函数传递参数是这样的:

x, y, z = 1, 2, 3

def add(a, b, c):

    return a+b+c

add(x, y, x)        # 使用变量,传递参数
add(4, 5, 6)        # 直接传递值也是可以的。

在上面的例子中,a,b,c叫做形式参数,简称形参。而x,y,z和4,5,6叫做实际参数,简称实参,也就是实际要传递的值。而我们通常讨论的参数,指的都是形参。

定义函数时,参数的名字和位置确定下来,函数的接口就固定了。对于函数的调用者来说,只需要知道如何传递正确的参数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用者无需了解。Python函数的参数定义灵活度非常大。除了正常定义的位置参数外,还可以使用默认参数、动态参数和关键字参数,这些都是形参的种类。

一、 位置参数

也叫必传参数,顺序参数,是最重要的,也是必须在调用函数时明确提供的参数!位置参数必须按先后顺序,一一对应,个数不多不少的传递!

上面例子中的a,b,c就是位置参数,我们在使用add(4, 5, 6)调用时,就是将4传给a,5传给b,6传给c的一一对应传递。类似add(4, 5, 6, 7)add(4)add(5, 4, 6)这种“画蛇添足”、“缺胳膊少腿”和“嫁错郎”类型的调用都是错误的。其中,add(5, 4, 6)的调用在语法上没问题,但是输出结果可能和预期的不一致。

注意: Python在做函数参数传递的时候不会对数据类型进行检查,理论上你传什么类型都可以!

def add(a, b, c):
    return a+b+c

result = add("haha", 2,  3)

但是,上面的add函数,如果你传递了一个字符串和两个数字,结果是弹出异常,因为字符串无法和数字相加。这就是Python的弱数据类型和动态语言的特点。在简单、方便的时候,需要你自己去实现数据类型检查。

Traceback (most recent call last):
  File "F:/Python/pycharm/201705/func.py", line 33, in <module>
    result = add("haha", 2,  3)
  File "F:/Python/pycharm/201705/func.py", line 31, in add
    return a+b+c
TypeError: must be str, not int

二、 默认参数

在函数定义时,如果给某个参数提供一个默认值,这个参数就变成了默认参数,不再是位置参数了。在调用函数的时候,我们可以给默认参数传递一个自定义的值,也可以使用默认值。

def power(x, n = 2):
    return x**n

ret1 = power(10)   # 使用默认的参数值n=2
ret2 = power(10, 4)  # 将4传给n,实际计算10**4的值

上面例子中的n就是个默认参数。默认参数可以简化函数的调用,在为最常用的情况提供简便调用的同时,还可以在特殊情况时传递新的值。但是在设置默认参数时,有几点要注意:

  • 默认参数必须在位置参数后面!

如果你违反了这点,在语法层面直接是通不过的。

# 这是一个错误的例子
def power(n = 2,x):
    return x**n
  • 当有多个默认参数的时候,通常将更常用的放在前面,变化较少的放后面。
def student(name, sex, age, classroom="101", tel="88880000", address="..."):
    pass
  • 在调用函数的时候,尽量给实际参数提供默认参数名。
def student(name, sex, age, classroom="101", tel="88880000", address="..."):
    pass

student('jack','male',17)       # 其它全部使用默认值
student('tom','male',18,'102','666666','beijing')    # 全部指定默认参数的值
student('mary','female',18,'102',tel='666666')  # 挑着来
student('mary','female',18,tel='666666','beijing')   #  这是错误的参数传递方式
student("mary","female",18,tel="666666",address="beijing")

注意最后两种调用方式,倒数第二种是错误的,而最后一种是正确的。为什么会这样?因为一切没有提供参数名的实际参数,都会当做位置参数按顺序从参数列表的左边开头往右匹配!

  • 使用参数名传递参数

通常我们在调用函数时,位置参数都是按顺序先后传入,而且必须在默认参数前面。但如果在位置参数传递时,给实参指定位置参数的参数名,那么位置参数也可以不按顺序调用,例如:

def student(name, age, classroom, tel, address="..."):
    pass

student(classroom=101, name="Jack", tel=66666666, age=20)

注意指定的参数名必须和位置参数的名字一样。

  • 默认参数尽量指向不变的对象!

下面是国内某上市互联网公司Python面试真题:

def func(a=[]):
    a.append("A")
    return a

print(func())
print(func())
print(func())

不要上机测试,仅凭代码,你能说出打印的结果吗?

很多同学可能会说,这还不简单,肯定是下面的结果啊:

['A']
['A']
['A']

真的是这样吗?错了!真正的结果是:

['A']
['A', 'A']
['A', 'A', 'A']

Why?为什么会这样?

因为Python函数体在被读入内存的时候,默认参数a指向的空列表对象就会被创建,并放在内存里了。因为默认参数a本身也是一个变量,保存了指向对象[]的地址。每次调用该函数,往a指向的列表里添加一个A。a没有变,始终保存的是指向列表的地址,变的是列表内的数据!我们可以测试一下:

def func(a=[]):
    print("函数内部a的地址为:%s" % id(a))
    a.append("A")
    return a

b = func()
print('此时b的值为:%s' % b)
print("函数外部b的地址为:%s" % id(b))
print("-------------")

c = func()
print('此时c的值为:%s' % c)
print("函数外部c的地址为:%s" % id(c))
print("-------------")

d = func()
print('此时d的值为:%s' % d)
print("函数外部d的地址为:%s" % id(d))

打印结果是:

函数内部a的地址为:39287880
此时b的值为:['A']
函数外部b的地址为:39287880
-------------
函数内部a的地址为:39287880
此时c的值为:['A', 'A']
函数外部c的地址为:39287880
-------------
函数内部a的地址为:39287880
此时d的值为:['A', 'A', 'A']
函数外部d的地址为:39287880

那么如何避免这个问题呢?

使用不可变的数据类型作为默认值!

def func(a=None):
    # 注意下面的if语句
    if a is None:
        a = []
    a.append("A")
    return a

print(func())
print(func())
print(func())

将默认参数a设置为一个类似None,数字或字符串之类的不可变对象。在函数内部,将它转换为可变的类型,比如空列表。这样一来,不管调用多少次,运行结果都是['A']了。

三、 动态参数

顾名思义,动态参数就是传入的参数的个数是动态的,可以是1个、2个到任意个,还可以是0个。在不需要的时候,你完全可以忽略动态函数,不用给它传递任何值。

Python的动态参数有两种,分别是*args**kwargs,这里面的关键是一个和两个星号的区别,而不是argskwargs在名字上的区别,实际上你可以使用*any**whatever的方式。但就如self一样,默认大家都使用*args**kwargs

注意:动态参数,必须放在所有的位置参数和默认参数后面!

def func(name, age, sex='male', *args, **kwargs):
    pass

1.*args

一个星号表示接收任意个参数。调用时,会将实际参数打包成一个元组传入形式参数。如果参数是个列表,会将整个列表当做一个参数传入。例如:

def func(*args):
    for arg in args:
        print(arg)

func('a', 'b', 'c')

li = [1, 2, 3]
func(li)

运行结果是:

a
b
c
[1, 2, 3]

通过循环args,我们可以获得传递的每个参数。但是li这个列表,我们本意是让它内部的1,2,3分别当做参数传递进去,但实际情况是列表本身被当做一个整体给传递进去了。怎么办呢?使用一个星号!调用函数,传递实参时,在列表前面添加一个星号就可以达到目的了。实际情况是,不光列表,任何序列类型数据对象,比如字符串、元组都可以通过这种方式将内部元素逐一作为参数,传递给函数。而字典,则会将所有的key逐一传递进去。

def func(*args):
    for arg in args:
        print(arg)

li = [1, 2, 3]
func(*li)

2.**kwargs

两个星表示接受键值对的动态参数,数量任意。调用的时候会将实际参数打包成字典。例如:

def func(**kwargs):
    for kwg in kwargs:
        print(kwg, kwargs[kwg])
        print(type(kwg))

func(k1='v1', k2=[0, 1, 2])

运行结果是:

k1 v1
<class 'str'>
k2 [0, 1, 2]
<class 'str'>

而如果我们这样传递一个字典dic呢?我们希望字典内的键值对能够像上面一样被逐一传入。

def func(**kwargs):
    for kwg in kwargs:
        print(kwg, kwargs[kwg])

dic = {
    'k1': 'v1',
    'k2': 'v2'
}

func(dic)

实际结果却是弹出错误,为什么?

Traceback (most recent call last):
  File "F:/Python/pycharm/201705/func.py", line 10, in <module>
    func(dic)
TypeError: func() takes 0 positional arguments but 1 was given

因为这时候,我们其实是把dic当做一个位置参数传递给了func函数。而func函数并不接收任何位置函数。那怎么办呢?使用两个星号

def func(**kwargs):
    for kwg in kwargs:
        print(kwg, kwargs[kwg])

dic = {
    'k1': 'v1',
    'k2': 'v2'
}

func(**dic)

有了前面一个星号的基础,这里我们应该很好理解了。两个星号能将字典内部的键值对逐一传入**kwargs

3.“万能”参数

*args**kwargs组合起来使用,理论上能接受任何形式和任意数量的参数,在很多代码中我们都能见到这种定义方式。需要注意的是,*args必须出现在**kwargs之前。

def func(*args, **kwargs):

    for arg in args:
        print(arg)

    for kwg in kwargs:
        print(kwg, kwargs[kwg])


lis = [1, 2, 3]
dic = {
    'k1': 'v1',
    'k2': 'v2'
}

func(*lis, **dic)

现在我们结合一下普通参数和万能参数,看看会有什么情况发生:

def func(a, b, c=1, *args, **kwargs):
    for arg in args:
        print(arg)

    for kwg in kwargs:
        print(kwg, kwargs[kwg])


lis = ['aaa', 'bbb', 'ccc']
dic = {
    'k1': 'v1',
    'k2': 'v2'
}

func(1, 2, *lis, **dic)

打印结果是:

bbb
ccc
k1 v1
k2 v2

列表lis中的第一个元素‘aaa’怎么没有打印出来?

我们改一下代码,打印一下参数c的结果就知道了:

def func(a, b, c=1, *args, **kwargs):
    print('c的值是:', c)
    for arg in args:
        print(arg)

    for kwg in kwargs:
        print(kwg, kwargs[kwg])


lis = ['aaa', 'bbb', 'ccc']
dic = {
    'k1': 'v1',
    'k2': 'v2'
}

func(1, 2, *lis, **dic)

打印结果为:

c的值是: aaa
bbb
ccc
k1 v1
k2 v2

原来,lis的第一个元素被传递给参数c了!这就是Python的参数传递规则之一。

4.关键字参数

对于*args**kwargs参数,函数的调用者可以传入任意不受限制的参数。比如:

def func(*args):
    pass

func("haha", 1, [], {})
func(1,2,3,4,5,6)

对于这样的参数传递方式,虽然灵活性很大,但是风险也很大,可控性差,必须自己对参数进行过滤和判定。例如下面我只想要姓名、年龄和性别,就要自己写代码检查:

def student(name, age, **kwargs):
    if 'sex' in kwargs:
        student_sex = kwargs['sex']

但是实际上,用户任然可以随意调用函数,比如student("jack", 18, xxx='male'),并且不会有任何错误发生。而我们实际期望的是类似student("jack", 18, sex='male')的调用。那么如何实现这种想法呢?

可以用关键字参数!关键字参数前面需要一个特殊分隔符*和位置参数及默认参数分隔开来,*后面的参数被视为关键字参数。在函数调用时,关键字参数必须传入参数名,这和位置参数不同。如果没有传入参数名,调用将报错。不同于默认参数,关键字参数必须传递,但是关键字参数也可以有缺省值,这时就可以不传递了,从而简化调用。

我们把前面的函数改写一下:

def student(name, age, *, sex):
    pass

student(name="jack", age=18, sex='male')

注意函数的定义体首行。

如果函数定义中已经有了一个*args参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。

def student(name, age=10, *args, sex, classroom, **kwargs):
    pass

student(name="jack", age=18, sex='male', classroom="202", k1="v1")

Python的函数参数种类多样、形态多变,既可以实现简单的调用,又可以传入非常复杂的参数。需要我们多下功夫,多写实际代码,多做测试,逐步理清并熟练地使用参数。



评论总数: 1



user_image
关键字参数前面需要一个特殊分隔符*和位置参数及默认参数分隔开来,*后面的参数被视为关键字参数

这个特性是py3的,我用的是py2...