python中函数的参数

1、函数参数有哪些？

• 必须参数(位置参数)
• 非必须参数(默认参数)
• 可变参数
• 关键字参数

2、例子

- 必须参数

如下，n为必传参数，当不传的时候会报错

def must_arg1(n):
    print(n)


def must_arg2(n):
    print(n)

if __name__ == '__main__':
    must_arg1("必传参数")
    must_arg2()

1
2
3
4
5
6
7
8
9
10
11

- 非必须参数

传参则取传递的值，不传的时候取默认值

def not_must_arg1(n,a=2):
    print(n,a)


def not_must_arg2(n,a=2):
    print(n,a)

if __name__ == '__main__':
    not_must_arg1(1)
    not_must_arg2(1,4)
1
2
3
4
5
6
7
8
9
10

1 2
1 4
1
2

- 可变参数

当我们传递参数的值不确定时，可以使用可变参数。如我们计算传递参数的总和

def add(a,b):
    print(a+b)


def add_change(*args):
    print(type(args))
    print(args)
    sum=0
    for arg in args:
        sum+=arg
    print(sum)


if __name__ == '__main__':
    add(1,2)
    add_change(1,2,3,4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3
<class 'tuple'>
(1, 2, 3, 4)
10
1
2
3
4

> 由此可以见*args把传进来的参数组合成了元组

• 关键字参数

如下，可以根据关键字来传递

def add(a, b):
    print("a",a)
    print("b",b)


if __name__ == '__main__':
    add(b = 1, a = 2)
1
2
3
4
5
6
7

a 2
b 1
1
2

如果传递的关键字参数个数不固定呢？

def add(**kwargs):
   print(type(kwargs))
   for key,value in kwargs.items():
       print(key,value)



if __name__ == '__main__':
    add(a=2,b=4,c=6)

1
2
3
4
5
6
7
8
9
10

<class 'dict'>
a 2
b 4
c 6


1
2
3
4
5
6

由此可见关键字参数会把所有参数组合成字典

3、装包、拆包(解包)

• 装包(多个参数变成一个)

如可变参数、关键字参数。可变参数*args把参数组装成元组，**kwargs把参数组装成字典

def add_change(*args):
    print(type(args))
    print(args)
    sum=0
    for arg in args:
        sum+=arg
    print(sum)

def add(**kwargs):
   print(type(kwargs))
   for key,value in kwargs.items():
       print(key,value)


if __name__ == '__main__':
    add_change(1,2,3)

    print('---------------------')

    add(a=2,b=4,c=6)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 拆包(一个参数变成多个)，

def add_change(*args):
    print(type(args))
    print(args)
    sum=0
    for arg in args:
        sum+=arg
    print(sum)

def add(**kwargs):
   print(type(kwargs))
   for key,value in kwargs.items():
       print(key,value)

if __name__ == '__main__':
   tuple1= (2,3,4)
   add_change(*tuple1)

   print("--------------------")

   dict1={"name":"xian","age":"22"}
   add(**dict1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<class 'tuple'>
(2, 3, 4)
9
--------------------
<class 'dict'>
name xian
age 22
1
2
3
4
5
6
7

原理

• 可变参数:

*tuple1先进行拆包，把(2,3,4)拆成 2 3 4,传进去add_change(arg)函数中，此时函数中的可变参数arg再把2 3 4装包成元组。即拆包后又重新进行装包

• 关键字参数:
  **dict1先进行拆包，name=“xian”,age=“22”，传递给add(kwargs)函数中，此时函数中的kwargs再把name=“xian”,age="22"进行装包成字典