Python 函数参数

---

没啥用的话：

---

最近复习了python的基础语法，发现很多东西都已忘记，现在重新捡起来，以博客的方式记录，以便巩固和复习

---

python中的函数参数

在python中构造函数是个再简单不过的过程了，只需要像下面这样。

def 函数名(参数1，参数2，....):  
    函数体

其中函数名可以随意取，自己写程序的话只要函数名自己知道啥意思就行；函数体就要根据函数具体功能来编写啦。这里主要介绍函数的参数。
函数的参数包括以下五类：
1.必须参数、
2.默认参数、
3.可变参数、
4.关键字参数、
5.组合参数。

下面我将对以上五类参数进行详述。

1.必须参数

def add(a, b, c, d): 
    result = a + b + c + d
    print(result)

当我们调用add函数时，必须要在函数中体现这四个参数,

add(1, 2, 3 ,4)
>>>10

其中a, b, c, d就为函数的必须参数.
但有时，我们的函数体本身不需要参数，比如我们只想打印某句话的时候，这时函数参数也就不不必须的，例如：

def add(a, b, c, d): 
    print(‘hello world！’)

结果等同于

def printf(): 
    print(‘hello world！’)

不同的是，调用add()函数的时候，要把参数补齐。

add(s, 4, 5, l)就相当于 printf()
>>>hello world!

2.默认参数

在定义函数时，形参给定一个值，这就是默认参数。例如

def add_1(a, b=10, c=20, d=30):  
    result = a + b + c + d
    print(result)

当我们调用add_1()时，只需要将参数a进行带入即可

add_1(5)
>>>65

但有时我们想更改默认参数的值，只需要将想更改的值带入函数中默认参数的位置即可，例如：

add_1(5, 100)
>>>155

此时，a = 5,b = 100,100就会覆盖b原来的默认值。但是，如果我们想改变靠后位置的默认值的时候，我们可以在调用函数的时候对默认参数进行赋值操作，例如：

add_1(5, c=50)
>>>95

此时，a = 5,b=10,c = 50,d=30.50就会覆盖c原来的默认值20。
当默认参数较多时，也可以改变其参数的默认值，

def func(a,b=10,c=3):
    print(a,b,c)

func(3,c=10,b=7)
>>>3, 7, 10

3.可变参数

可变参数起到函数传递参数的作用。形式为：
*args:接收N个位置参数，并转换成元组tuple形式
其中，args是非固定的，你可以换各种名称，前提是在名称前要有且仅有一个 *（星号）。
具体看下面的简单示例：

def func(a, b, c, *d):
    print(a, b, c, d)

func(1,2)  
>>>报错，因为参数数目不对
func(1,2,3,4)  
>>>1, 2, 3, (4,)
func(1, 2, 3, 4, 5, 6, 7, 8, 9) 
>>>1, 2, 3, (4, 5, 6, 7, 8, 9) 

从上面的例子可以看出，调用函数时，在满足函数定义时的必要参数的个数，其余的便以元组的形式传递出来，也就是说它相当于一个大的容器，可以容纳很多个参数。当元祖中仅有一个元素的时候，千万不要忽略了后面的逗号。实际上就是一个装包的过程。
如果，我们的参数是元组、列表或者字符串呢？我们看下面的示例：

L = [1,2,3,4,5]
T = (6,7,8,9,10)
def func_1(a, *args):
	print(a, args)

func_1(0,T)
>>>0,((6,7,8,9,10)，)
func_1(0,L)
>>>0, ( [1,2,3,4,5]，)

重上面的例子可以看出，*args将元组或者列表转换成装包后元组的一个元素。
那么新的问题来了，如果在调用的时候参数前添加 *号呢？接下来我们看下面的例子：

L = [1,2,3,4,5]
T = (6,7,8,9,10)
def func_1(a, *args):
	print(a, args)

func_1(0,*T)
>>>0, (6,7,8,9,10)
func_1(0,*L)
>>>0, (1,2,3,4,5)

原来的列表L在调用函数func_1()后变成了元组，而原来的元组T在调用函数func_1()后保持不变，也可以说由元组转换成元组。实际上，这个过程可以理解为装包–>拆包–》装包的过程。

4.关键字参数

关键字参数就是在调用函数时，传入实参时带参数名，用这样的方式传入的实参叫做关键字参数。一个简单的形式如下：

def func(**kwargs): 
    ............

具体我们通过下面的例子进行讲解，

def func_2(**kwargs): 
    print(kwargs)

func_2(a=1,b=2,c=3) 
>>>{'a': 1, 'b': 2, 'c': 3}

**kwargs就是说，只要调用函数送值，送的值必须是key=value的形式，输出为字典形式。
我们看下面的一个示例：

dict1 = {'001':'机电工程','002':'计算机科学','003':'电子信息','004':'新媒体'}
def func_2(**kwargs):
    print(kwargs)

func_2(**dict1)
>>>{'001':'机电工程','002':'计算机科学','003':'电子信息','004':'新媒体'}

重上面的例子可以分为以下几个步骤：
1.将字典进行拆包，func_2(001=机电工程,002=计算机科学,…)
2.func_2里面的参数都是关键字参数
3.将关键字参数进行一次装包动作
4.装包成功：kwargs
原理其实与*args差不太多，只不过是将元组换成了字典。
下面来一个复杂的示例：

students_choose = {'01':('机电工程学院', 01),"02":("计算机科学与技术学院",02),"03":('电子信息工程学院',03),'04':('新媒体艺术学院',04)}
def choose_college(name,**college):
print('{}想选择的学院是：'.format(name))
    if isinstance(college,dict):
        for name, num in college.values():
            print('{}的编号为：{}'.format(name,num))
# 调用
choose_college('小明'，**students_choose )
>>>小明想选择的可学院是：
>>>机电工程学院的编号为：01
>>>计算机科学与技术学院的编号为：02
>>>电子信息工程学院的编号为：03
>>>新媒体艺术学院的编号为：04

5.组合参数

顾名思义，组合参数就是定义函数时，出现多类型参数形式，如下例所示：

def func_3(a,b=1,c=2,**kwargs):
    print(a,b,c,kwargs)

func_3(5)
>>>5 1 2 {}
func_3(5，b=10)
>>>5 10 2 {}
func_3(5,9,10,a=1,b=2)
>>>报错 变量名不可重复使用
func_2(3,c=5,b=7,x=1,y=2)
>>>3 7 5 {'x': 1, 'y': 2}

对于上述组合参数我们需要注意一下点：
1.变量名不可以重复使用；
2.关键值参数必须以key=value的形式给出，并且输出为字典；
3.关键值参数为非必要参数，可以不给予其值，输出为空字典；
4.默认参数数值可以改变。
下面我们看更多类型参数的示例：

L = [1,2,3,4,5]
T = (6,7,8,9,10)
D = {'1':'i','2':'j','3':'k'}
def func_4(a,b=10,c=20,*args,**kwargs):
    print(a,b,c,args,kwargs)

func_4(5)
>>>5 10 20 () {}
func_4(5,7)
>>>5 7 20 () {}
func_4(5,c=100,b=20)
>>>5 20 100 () {}
func_4(5,*L)
>>>5 1 2 (3, 4, 5) {}
>>>将L拆包后1赋值给b，2赋值给c，其余的进行装包
func_4(5,L)
>>>5 [1, 2, 3, 4, 5] 20 () {}
>>>将L整体赋值给b，c不变
func_4(5,*T)
>>>5 6 7 (8, 9, 10) {}
>>>将T拆包后6赋值给b，7赋值给c，其余的进行装包
func_4(5,T)
>>>5 (6, 7, 8, 9, 10) 20 () {}
>>>>将T整体赋值给b，c不变
func_4(5,d=9,e=6)
>>>5 10 20 () {'d': 9, 'e': 6}
func_4(5,**D)
>>>5 10 20 () {'1': 'i', '2': 'j', '3': 'k'}
func_4(5,b=20,c=30,*L,**D)
>>>TypeError: func_4() got multiple values for argument 'b'
>>>原因是，参数b获得了多个参数，在函数拆包时，将L列表赋值给b，同时b=20，因此报错。
func_4(5,*L,**D)
>>>5 1 2 (3, 4, 5) {'1': 'i', '2': 'j', '3': 'k'}
func_4(5,*T,**D)
>>>5 6 7 (8, 9, 10) {'1': 'i', '2': 'j', '3': 'k'}
func_4(5,L,**D)
5 [1, 2, 3, 4, 5] 20 () {'1': 'i', '2': 'j', '3': 'k'}
func_4(5,T,**D)
5 (6, 7, 8, 9, 10) 20 () {'1': 'i', '2': 'j', '3': 'k'}
>>>

以上就是我总结的函数参数的所有内容。