python - 自定义函数

1 判断某个对象是否为函数

使用内置函数 callable 判断一个对象是否为一个函数：

>>> import math
>>> d={}
>>> func=math.ceil
>>> callable(d)
False
>>> callable(func)
True

d 是一个字典，所以 callable(d) 为 False；ceil 为一个函数，所以 callable(func) 为 True

2 自定义一个函数

使用 def 关键字进行函数自定义，下面定义一个返回斐波拉契列表的函数：

def fibonacci(number):
    result = [0, 1]
    for i in range(number - 2):
        result.append(result[-2] + result[-1])
    return result

调用 fibonacci 函数：

>>> fibonacci(20)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]

3 函数参数

3.1 参数不能改变

>>> def change_parameter(param):
...     param='Andy Lau'
...
>>> name='Steven Chow'
>>> change_parameter(name)
>>> name
'Steven Chow'

上面的代码中，定义了一个 change_parameter 修改了形参 param，但实参并未因此被修改。

3.2 关键字参数

下面定义两个同样用于计算两个数和的方法：

def add(x, y):
    sum=x+y
    print(x,'+',y,'=',sum)

def add_2(y, x):
    sum=x+y
    print(x,'+',y,'=',sum)

分别调用 add 和 add_2 函数：

>>> add(2,3)
2 + 3 = 5
>>> add_2(3,2)
2 + 3 = 5

这两个函数的功能是一样的，只是参数的顺序不同。

当一个函数的参数很多时，参数的顺序是难以记住的。因此，在调用函数，传入实参时，可指定参数的名称：

>>> add(x=10,y=22)
10 + 22 = 32
>>> add(y=22,x=10)
10 + 22 = 32

3.3 参数默认值

可以在定义函数时，为参数指定默认值：

def function_name(param1, param2=value2, ...):

但要谨记，需要设置默认值的参数，必须定义在其他参数之后，否则会出现语法错误 SyntaxError，例如：

>>> def greet(greeting='Hello', name):
...     return f'{greeting}, {name}'
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

由于 greeting 参数需要设置默认值，因此，它必须放在 name 参数后：

>>> def greet(name, greeting='Hello'):
...     return f'{greeting}, {name}'
...
>>> greet('Tom')
'Hello, Tom'

3.4 可变数量参数

可变数量参数全称为 Variable Number Of Arguments。

有时候，我们不能确定参数的数量，因此，希望函数能够接受可变数量的参数：

def multiply(initial_value=1, *numbers):
    print('*numbers is {}'.format(numbers))
    result = initial_value
    for num in numbers:
        result *= num
    return result

调用 multiply 函数：

>>> multiply(2,3,4,5)
*numbers is (3, 4, 5)
120

从运行结果，我们可以知道 可变数量参数 *numbers 其实就是一个 元组。

3.5 关键字参数

关键字参数全称为 Keyword Arguments，在函数定义中使用两个星号修饰参数，**kwargs

def info(**kwargs):
    print(kwargs)
    for key, value in kwargs.items():
        print(key, ":", value)

调用 info 函数：

>>> info(name='Steven Chow', age=60, city='HK')
{'name': 'Steven Chow', 'age': 60, 'city': 'HK'}
name : Steven Chow
age : 60
city : HK

可以看到，关键字参数，其实就是一个字典对象。

关键字参数 和 可变数量参数 是可以一起使用的，原则是:

(1) 这两种参数必须定义在其他参数之后。

(2) 关键字参数 必须定义在 可变数量参数 之后。

例如：

def info(greeting, *args, **kwargs):
    print(greeting)
    print('args={}'.format(args))
    print('kwargs={}'.format(kwargs))
    for key, value in kwargs.items():
        print(key, ":", value)

调用 info 函数：

>>> info('hello', 'param1', 'param2', name='Steven Chow', age=60, city='HK')
hello
args=('param1', 'param2')
kwargs={'name': 'Steven Chow', 'age': 60, 'city': 'HK'}
name : Steven Chow
age : 60
city : HK

3.6 解包

解包就是对集合进行分解，例如：

>>> x,y,z=(1,2,3)
>>> x
1
>>> y
2
>>> z
3

在调用函数时，可以使用 * 对序列解包，作为 可变数量参数 传递；使用 ** 对字典解包，作为 关键字参数 传递：

def print_params(param1,param2,param3,*args,**kwargs):
    print('param1={},param2={},param3={}'.format(param1,param2,param3))
    print('args={}'.format(args))
    print('kwargs={}'.format(kwargs))

调用 print_params 函数：

>>> args=(1,2,3,4,5)
>>> kwargs={'name': 'Tom','age': 60}
>>> print_params('value1','value2','value3',*args,**kwargs)
param1=value1,param2=value2,param3=value3
args=(1, 2, 3, 4, 5)
kwargs={'name': 'Tom', 'age': 60}