Python基础知识- 函数定义，参数问题(hard)

如果已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431679203477b5b364aeba8c4e05a9bd4ec1b32911e2000

 

默认参数、可变参数和关键字参数

1. 默认参数

函数定义最常用的是为一个或多个参数指定默认值，这会创建一个比定义的参数更少的参数调用函数。

有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如

# 一年级小学生注册的函数，需要传入name,gender,age,city四个参数，其中age和city有默认值

# 默认参数的使用

def enroll(name, gender, age=6, city='Beijing'):

    print('name:', name)

    print('gender:', gender)

    print('age:', age)

    print('city:', city)

调用enroll('Bob', 'M', 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。

默认参数有个最大的坑    定义默认参数要牢记一点：默认参数必须指向不变对象！

 

要修改上面的例子，我们可以用None这个不变对象来实现：

def add_end(L=None):

    if L is None:

        L = []

    L.append('END')

    return L

# 测试

现在，无论调用多少次，都不会有问题：

>>> add_end()

['END']

>>> add_end()

['END']

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431752945034eb82ac80a3e64b9bb4929b16eeed1eb9000

2. 可变参数

可变参数就是传入的参数个数是可变的。例如，数学上计算一组数字的平方和。

def calc(numbers):

    sum = 0

    for n in numbers:

        sum = sum + n * n

    return sum

但是调用的时候，需要先组装出一个list或tuple：

>>> calc([1, 2, 3])

14

>>> calc((1, 3, 5, 7))

84

如果利用可变参数，调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)

14

>>> calc(1, 3, 5, 7)

84

所以，我们把函数的参数改为可变参数：

def calc(*numbers):

    sum = 0

    for n in numbers:

        sum = sum + n * n

    return sum

>>> nums = [1, 2, 3]

>>> calc(*nums)

14

Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去。*nums表示把nums这个list的所有元素作为可变参数传进去。

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

3.关键字参数

而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict（键值对）。
关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。

def person(name, age, **kw):

    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Bob', 35, city='Beijing')

name: Bob age: 35 other: {'city': 'Beijing'}

>>> person('Adam', 45, gender='M', job='Engineer')

name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
 

def person(name, age, **kw):

    if 'city' in kw:    # 有city参数

        pass

    if 'job' in kw:    # 有job参数

        pass

    print('name:', name, 'age:', age, 'other:', kw)



#测试结果：

>>> from fun_per import person

>>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

name: Jack age: 24 other: {'city': 'Beijing', 'addr': 'Chaoyang', 'zipcode': 123456}

命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

def person(name, age, *args, city, job):

    print(name, age, args, city, job)

# 测试结果：

>>> from fun_per import person

>>> person('Jack', 24, 'Beijing', 'Engineer')

Traceback (most recent call last):

    File "<stdin>", line 1, in <module>

TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'

>>> person('Jack', 24, 'city'='Beijing', 'job'='Engineer')

    File "<stdin>", line 1

SyntaxError: keyword can't be an expression

>>> person('Jack', 24, city='Beijing', job='Engineer')

Jack 24 () Beijing Engineer

命名关键字参数可以有缺省值，从而简化调用，由于命名关键字参数city具有默认值，调用时，可不传入city参数。

 

def person(name, age, *, city='Beijing', job):

    print(name, age, city, job)

# 测试结果：

>>> person('Jack', 24, job='Engineer')

Jack 24 Beijing Engineer

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数。

 

def person(name, age, city, job):    # 缺少 * ，city和job被认为是位置参数

    pass

 

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

 

# 参数组合

# 参数定义顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):

# 必选参数、默认参数、可变参数、关键字参数

    print('a=', a, 'b=', b, 'c=', c, 'args=', args, 'kw=', kw)

def f2(a, b, c=0, *, d, **kw):

# 必选参数、默认参数、命名关键字参数、关键字参数

    print('a=', a, 'b=', b, 'c=', c, 'd=', d, 'kw=', kw)

# 测试结果：

>>> from fun_mix import f1,f2

>>> f1(1, 2)

a= 1 b= 2 c= 0 args= () kw= {}

>>> f1(1, 2, c=3)

a= 1 b= 2 c= 3 args= () kw= {}

>>> f1(1, 2, 3, 'a', 'b')

a= 1 b= 2 c= 3 args= ('a', 'b') kw= {}

>>> f1(1, 2, 3, 'a', 'b', x=99)

a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 99}

>>> f2(1, 2, d=99, ext=None)

a= 1 b= 2 c= 0 d= 99 kw= {'ext': None}

通过一个tuple和dict，可以调用上述函数：

# 测试结果：

>>> args = {1, 2, 3, 4}

>>> kw = {'d': 99, 'x': '#'}

>>> f1(*args, **kw)

a= 1 b= 2 c= 3 args= (4,) kw= {'d': 99, 'x': '#'}

>>> args = (1, 2, 3)

>>> kw = {'d': 88, 'x': '#'}

>>> f1(*args, **kw) # f1(a, b, c=0, *args, **kw) 其中*args为可变参数列表

a= 1 b= 2 c= 3 args= () kw= {'d': 88, 'x': '#'}

>>> f2(*args, **kw) # f2(a, b, c=0, *, d, **kw) 其中d为命名关键字参数

a= 1 b= 2 c= 3 d= 88 kw= {'x': '#'}

对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

 

小结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

# -*- coding: utf-8 -*-

# 以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积，利用可变参数列表

def product(*numbers):

    if numbers == (): # 对product()进行处理，注意numbers == ()，不是numbers == None

        raise TypeError

    result = 1

    for n in numbers:

        result = result * n

    return result

# 测试

print('product(5) =', product(5))

print('product(5, 6) =', product(5, 6))

print('product(5, 6, 7) =', product(5, 6, 7))

print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))

if product(5) != 5:

    print('测试失败!')

elif product(5, 6) != 30:

    print('测试失败!')

elif product(5, 6, 7) != 210:

    print('测试失败!')

elif product(5, 6, 7, 9) != 1890:

    print('测试失败!')

else:

    try:

        product()

        print('测试失败!')

    except TypeError:

        print('测试成功!')