Python全栈自动化系列之Python编程基础（函数函数的参数拆包和打包）

Posted 2021-03-16 bluesea-zl

一、函数

1）定义：函数就是对功能的封装，函数可以是用来封装我们的代码；2）python中内置函数是事先封装好的，可以直接使用

2）自己封装函数，使用关键字def

语法：　　def　　函数名（）：

　　　　　　　　函数体（函数内部的代码）

注意点：函数定义之后，不会直接执行，只有在调用函数时，才会使用函数

关键字：pass，没有语义，表示一行空代码（占位置）

3）函数调用：函数名（）

　　def　　func():

　　　　pass

4)小案例

需求：定义一个会打印三角形的函数

 

　　def func():
　　　　for i in range(1,5):
　　　　　　　　for j in range(1,i+1):
　　　　　　　　　　print(‘* ‘,end="")   # 不换行

　　　　　　　　　print()    # 什么都不打印就是换行

　　# 调用函数
　　func()

 

运行结果：

 

 

 二、函数的返回值，使用关键字return

1）a.函数调用之后，是否有返回值是由return来决定的；

　  b.函数没有写return，则函数返回的内容为None（为空）

　  c.return后面写什么，函数返回的就是什么（但注意要写python中认识的数据类型）

注意点：

　　1、一个函数中只会执行一个return，函数执行到return之后就不会再继续执行，会直接跳出函数
　　2、函数可不可以写多个return？可以写多个，但是注意：同一个分支只有一个return
　　3、函数如何返回多个值？直接写在ruturn后面，用逗号隔开；返回两个及以上的元素，会返回一个元组

三、函数的参数

1）参数类型：形参和实参

• 形参：在定义函数的时候，定义的参数，叫形参（形式上的参数，并没有确定值是多少），形参是用来接收实参传递的值
• 形参的类型：①必须参数（必备参数）：定义了几个就要传几个，不能多也不能少

　　　　　　　　   ②默认参数（缺省参数）：定义的时候给一个默认值，调用函数时，该参数可以传也可以不传，不传时就用默认值

　　　　　　　　   ③不定长参数（动态参数）：可以用来接收0个或者多个参数（可接收的参数不限定长度（参数个数））　　　　　　　　　

　　　　　　　　　　　　a.*arge:可以用来接收0个或者多个参数，只能接收以位置参数传递的参数，以元组形式保存

　　　　　　　　　    　b.**kwargs:可以用来接收0个或者多个参数，只能接收以关键字指定参数传参方式传递的参数，以字典形式保存

　　注意点：不定长参数必须定义在必须参数和默认参数之后

 

• 实参：在调用函数的时候，传入进入的参数，叫实参（实际的参数）
• 实参类型：①默认按位置顺序进行传递，这个传参的形式就做位置参数（通过参数的位置顺序进行传参）

　　　　　　　   ②通过参数名指定参数进行传递，这种传参形式叫做关键字参数（通过名字指定传参）

2）案例：

需求：定义一个可以实现任意两个数相加，返回相加的结果

　　def func(a,b):
　　　　print("a的值为{}，b的值{}".format(a,b))
　　　　　　return a + b

　　# 位置传参
　　print(func(100,200))

　　# 关键字传参(不用按顺序传递)
　　func(b=100,a=200)

运行结果：

示例：

　　a.必须参数：定义了几个就要传几个，不能多也不能少

　　def func(a,b):
　　　　print("a的值：{}".format(a))
　　　　print("b的值：{}".format(b))
　　　　return a +b

　　res = func(11,22)
　　print("相加的结果为:{}".format(res))

运行结果：

 

 

 　　b.默认参数（缺省参数）：定义的时候给一个默认值，调用函数时，该参数可以传也可以不传，不传时就用默认值

　　def func(a,b=99):
　　　　print("a的值：{}".format(a))
　　　　print("b的值：{}".format(b))
　　　　return a +b

　　# 给b传了一个值
　　res = func(11,22)

　　# b不传就取默认参数
　　res1 = func(11)
　　print("相加的结果为:{}".format(res1))

运行结果：

 

 

 　　c.不定长参数（动态参数）*args（注意只能接收以位置参数传递的参数，以元组形式保存）

　　def func(a,b,*args):
　　　　print("a的值：{}".format(a))
　　　　print("b的值：{}".format(b))
　　　　print("arges的值:{}".format(args))
　　　　return a +b

　　res = func(11,22,888,999,777,222) # 可以传多个参数（位置参数）
　　print("相加的结果为:{}".format(res))

　　res = func(a=11,b=22,) # 可以少传
　　print("相加的结果为:{}".format(res))

运行结果：

 

 

 　　d.不定长参数（动态参数）**kwargs（注意只能接收以关键字指定参数传参方式传递的参数，以字典形式保存）

　　def func(a,b,**kwargs):
　　　　print("a的值：{}".format(a))
　　　　print("b的值：{}".format(b))
　　　　print("kwargs的值:{}".format(kwargs))
　　　　return a +b

　　res = func(a=11,b=22,c=333,d=999)
　　print("相加的结果为:{}".format(res))

运行结果：

 

 

 四、拆包（使用*和**拆包，只能在调用函数传递参数的时候）

*：可以用来对元组/列表/字符串进行拆包（注意是在调用函数的时候）

**：可以用来对字典进行拆包

1）*：对列表和元组拆包

　　def func(a,b,c):
　　　　print("a的值：{}".format(a))
　　　　print("b的值：{}".format(b))
　　　　print("c的值：{}".format(c))

　　li = [1,2,3]
　　tu = (11,22,33)
　　dic = {"a":"111","b":"222","c":"333"}

　　"""
　　*：对列表和元组拆包
　　"""

　　func(*li)

　　func(*tu)

运行结果：

　　"""
　　**:对字典进行拆包
　　"""

　　func(**dic)

运行结果：

 

 

 五、打包（打包只有在定义不定长参数的时候才能使用）

1）定义参数的时候在参数前面，加上*或者**，那么这个参数就是一个不定长参数

2）带有一个*的不定长参数，会将接收的参数，打包成一个元组

3）带有两个**的不定长参数，会将就收的参数，打包成一个字典