整体：
1. 函数的返回值的打包与拆包
2. 为函数的参数设置默认值
3. 函数参数的打包与拆包
----函数返回值的打包
def 函数名（参数列表）：
函数体执行内容
return 返回值1，返回值2，返回值3，...
此时调用函数时，变量 = 函数名（传参），变量得到的是一个打包后返回值的元祖类型数据，元祖内包含了所有返回值
函数的返回值可以是Python的所以类型数据，包括字符串，数值，None，列表，元祖，字典，对象等
>>> def dest(a,b,c,d):
print("传入的值,a:%s,b:%s,c:%s,d:%s" % (a,b,c,d))
return a,b,c,d
#dest(1,2,3,4),函数被调用，执行了函数体，所以打印输出了数据
>>> var = dest(1,2,3,4)
传入的值,a:1,b:2,c:3,d:4
#var存储了dest函数的返回值
>>> var
(1, 2, 3, 4) #默认打包返回一个元祖
#使用列表
>>> def dest1(a,b,c,d):
return [a,b,c,d]
>>> var1 = dest1(1,2,3,4)
>>> var1
[1, 2, 3, 4] #返回了一个列表
>>> 函数返回多个值时，默认打包成一个元祖，虽然没有用（）包裹，可以理解成一个变异元祖，除了没有括号包裹，其它都一样
注意：当多个值时，因为默认是返回一个元祖，所以当多个值时不可以再使用（）包裹，包裹会报错
默认返回元祖的形式，但是可以使用[ ]包裹，会进行打包返回一个列表形式的数据
----函数返回值的拆包
def 函数名（参数列表）：
函数体执行内容
return 返回值1，返回值2，返回值3，...
变量1，变量2，变量3，... = 函数名（参数列表）
使用多个变量进行接收数据就可以进行返回值的拆包
>>> def dest2(a,b,c,d):
return a,b,c,d
#一个变量接收多个返回值，会被自动打包成一个元祖类型的数据
>>> var = dest2(1,2,3,4)
>>> var
(1, 2, 3, 4)
#使用多个变量与返回值一一对应接收，返回值数据会被拆包，对变量进行一一赋值
>>> var1,var2,var3,var4 = dest2(1,2,3,4)
>>> var1
1
>>> var2
2
>>> var3
3
>>> var4
4
>>> 注意：变量需要与返回值一 一对应，数量量不能出现错误，否则会报错
----为函数参数设置默认值
def 函数名(普通参数,缺省参数=默认值)
注意：缺省参数要放在所有的普通参数后面
定义函数时，可以给一个参数设定一个默认值，当该参数没有被传参时，函数体内使用默认值参与计算
>>> def dest(name,age,sex='保密'):
print("姓名：%s，性别：%s，年龄：%s"%(name,sex,age))
#缺省参数不传入数据，会使用默认值
>>> dest('小明',18)
姓名：小明，性别：保密，年龄：18
#传入值时，会使用传入的数据
>>> dest('小蓝',18,'女')
姓名：小蓝，性别：女，年龄：18
>>> 注意：默认值不要设置成可变类型，因为函数定义后只会被初始化一次，默认值是该函数共享的
>>> def dest(a,b=[]):
b.append(a)
print(b)
#调用同一个函数传入同样的参数，执行结果却不一样
>>> dest(1)
[1]
>>> dest(1)
[1, 1]
>>> dest(3)
[1, 1, 3]如果是可变类型的数据，将可能会被函数调用发生修改，出现不符合预期的结果
----函数传参时的打包
区别 ：*不定长参数可以接收单一的元素，将所有的值进行打包成一个元祖给函数内使用
**不定长参数是接收键值对，将所有的键值对打包成一个字典给函数内使用
def 函数名(普通参数,*不定长参数)
定义一个函数时，需要传入参数长度不固定时可以使用不定长参数，此时传入的单一值，都会被打包成一个元祖，供函数体内使用
>>> def dest(a,*arge):
print("a:%s,arge:%s"%(a,arge))
>>> dest(1,'s',(1,2,3,4),[1,2,3,4],'测试',1,2,34,{'name':'小明','age':18},' 所有数据')
#打印结果
a:1,arge:('s', (1, 2, 3, 4), [1, 2, 3, 4], '测试', 1, 2, 34, {'name': '小明', 'age': 18}, ' 所有数据')
#第一个变量直接接收一个数据，其它的数据全部被打包成一个元祖被*arge接收def 函数名(普通参数，**不定长参数)
定义一个函数时，需要传入参数长度不固定时可以使用不定长参数，此时传入的键值对，都会被打包成一个字典，供函数体内使用
>>> def dest(a,*arge,**kwarges):
print("a:",a)
print('arge:',arge)
print('kwarges:',kwarges)
#对比，*不定长只接受单一的值，而**不定长是进行接收键值对
>>> dest(1,2,3,45,'a',(1,2,3),[1,6,8],name="小明",age=18,sex="男")
a: 1
arge: (2, 3, 45, 'a', (1, 2, 3), [1, 6, 8])
kwarges: {'name': '小明', 'age': 18, 'sex': '男'}注意：
当出现*不定长参数时，缺省参数必须放在*不定长参数的最后，这是语法规定，不必过多纠结
当出现**不定长参数时，缺省参数必须放在**不定长参数的前面，，。
当出现*不定长和**不定长时，参数列表顺序为：def 函数名（普通参数，*不定长参数 ，缺省参数=默认值，**不定长参数）
----函数传参时的拆包
当需要将一组数据传入函数内使用时，可以使用*拆包，将一组数据拆分成一个个参数
>>> def dest1(a,*arge):
print("a:",a)
print("arge:",arge)
#定义一个列表数据
>>> a = [1,2,3,4]
#将多个列表作为参数传入
>>> dest1(a,a,a,a)
a: [1, 2, 3, 4]
arge: ([1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]) #每一个列表被当做一个元素打包到元祖中
#传参时使用*拆包，列表中的元素被取出，每一个元素单独作为一个参数传入
>>> dest1(a,*a)
a: [1, 2, 3, 4]
arge: (1, 2, 3, 4)
#对比上面一下
>>> dest1(a,a)
a: [1, 2, 3, 4]
arge: ([1, 2, 3, 4],)
>>> 函数内使用不定长时，也可以在函数内进行拆包使用
>>> a = [90,87,67,92,76,80]
>>> def dest(a,*arge):
print("a:",a)
print("arge:",arge)
print("*arge",*arge)
>>> dest(1,a,a)
a: 1
arge: ([90, 87, 67, 92, 76, 80],[90, 87, 67, 92, 76, 80])
*arge [90, 87, 67, 92, 76, 80] [90, 87, 67, 92, 76, 80]**是将字典拆成键值对，使用*对字典拆包只会获得字典的所有的键
>>> def dest(*arge,**kwarges):
print("arge:",arge)
print("kwarges:",kwarges)
#定义两个数据用于使用
>>> a = (1,2,3,4,5)
>>> b = {'name':'小明','age':'18','sex':'男'}
#不拆包，两个参数都被当做成一个元素传入到了*不定长变量中，**只接受键值对
>>> dest(a,b)
arge: ((1, 2, 3, 4, 5), {'name': '小明', 'age': '18', 'sex': '男'})
kwarges: {}
#进行拆包，两个数据被拆包成多个数据传入，字典被*拆包只会得到键值的元素，**不定长还是没有得到数据
>>> dest(*a,*b)
arge: (1, 2, 3, 4, 5, 'name', 'age', 'sex')
kwarges: {}
#对字典数据使用**拆包，得到了键值对传入，**不定长接收到了数据并打包成一个字典
>>> dest(*a,**b)
arge: (1, 2, 3, 4, 5)
kwarges: {'name': '小明', 'age': '18', 'sex': '男'}