Python之函数初识
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数的基本语法：
def 函数名（参数列表）: 函数体
实例：
#定义函数
def get_len():
lis = [1, 2, 3, 4, 5, 6]
count = 0
for i in lis:
count += 1
get_len() #函数名()-->执行此函数
注：函数是以功能为导向,函数内部尽量不要有print()函数
一、函数的返回值
return
1、遇到return 此函数结束,不在向下进行
2、return 返回值
不写return 返回 None
return None 返回 None
return 单个值 返回此单个值
return 多个值 将多个值包在元组中,返回给调用此元组
2.1、return 程序结束
def my_test():
print(1111)
return #程序结束
print(2222) #没有输出
my_test()
#输出结果：
1111
2.2、return 返回单个值
def get_len():
lis = [1, 2, 3, 4, 5, 6]
return len(lis)
ret = get_len()
print(ret)
#输出结果：
6
2.3、return 返回多个值
def get_values():
return 1,2,[111,222]
ret1,ret2,ret3 = get_values()
print(ret1,ret2,ret3)
#输出结果
1 2 [111, 222]
二、函数传参
def get_sum(x): #形参：形式参数 count = 10 + x return count ret = get_sum(10) #实参：实际参数 print(ret) #20
1.1、从实参的角度：
1)、按位置传参
def mysum(x,y):
#此时x=10,y=20
return x + y
num = mysum(10,20) #位置参数
print(num) #30
2)、按关键字传参
def mymax(x,y):
#此时x = 20,y = 10
the_max = x if x > y else y
return the_max
maxN = mymax(y=10, x=20) #关键字传参
print(maxN) #20
3)、混合传参--关键字参数永远在位置参数后面
def mymax(x, y):
#此时x = 10,y = 20
the_max = x if x > y else y
return the_max
maxN = mymax(10, y=20) #10--位置参数，y=20--关键字参数
print(maxN) #20
1.2、从形参的角度：
1)、位置参数必须传值
def mymax(x, y):
the_max = x if x > y else y
return the_max
maxN = mymax() #此处不传参数
print(maxN)
#直接报错：
TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'
2)、默认参数（若不传递，会显示设置的默认值）
def stu_info(name, sex = "男"):
print(name,sex)
stu_info('alex') #alex 男
stu_info('eva','女') #eva 女
1.3、动态传参
动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。
1)、*args-->接收不定长的所有位置参数
#args可以接收不确定个数的参数
def func(*args):
print(args,type(args)) #(1, 2, 'alex') <class 'tuple'>
func(1,2,'alex')
#输出结果
(1, 2, 'alex') <class 'tuple'>
#若将*args放在最前边，它会接收全部参数，a,b就没有对应的实参了
def func(*args,a,b):
print(a)
print(b)
print(args,type(args))
func(1,2,'alex',3,4) #直接出错：func() missing 2 required keyword-only arguments: 'a' and 'b'
#*args放在最后，是正确的写法
def func(a,b,*args):
print(a)
print(b)
print(args,type(args))
func(1,2,'alex')
#输出结果
1 2 ('alex',) <class 'tuple'>
#有默认参数的时候，要放在*args后边
def func(a, b, *args, sex = '男'):
print(a)
print(b)
print(sex)
print(args,type(args))
func(1,2,'alex','wusir','ritian')
#输出结果
1 2 男 ('alex', 'wusir', 'ritian') <class 'tuple'>
#错误实例
def func(sex='男', *args):
print(sex) #1 直接把sex的默认值给覆盖了
print(args) #(2, 'alex')
func(1,2,'alex')
#输出结果
1 (2, 'alex')
2)、**kwargs-->接收所有的关键字参数
#接收关键字参数
def func(**kwargs):
print(kwargs) #{'a': 1, 'b': 4, 'c': 3}
func(a = 1, b = 4, c = 3)
#输出结果：
{'a': 1, 'b': 4, 'c': 3}
#位置参数、*args、默认参数、**kwargs
def func(a,*args,sex = '男', **kwargs):
print(a) #1
print(sex) #女
print(args,type(args)) #('alex', 'wusir', 'ritian ') <class 'tuple'>
print(kwargs, type(kwargs)) #{'name': 'taibai', 'age': 21} <class 'dict'>
func(1,'alex','wusir','ritian ',sex = '女',name = 'taibai',age = 21)
#输出结果
1
女
('alex', 'wusir', 'ritian ') <class 'tuple'>
{'name': 'taibai', 'age': 21} <class 'dict'>
#万能参数
def func(*args, **kwargs):
print(args) #(1,)
print(kwargs) #{'name': 'alex'}
func(1,name="alex")
#输出结果
(1,)
{'name': 'alex'}
总结
#参数摆放顺序：位置参数-->*args-->默认参数-->**kwargs
3)、魔法运算：打散后操作
#*魔法运算(列表):打散-->将列表里的每一个元素打散迭代添加到元组中
#求和
def func(*args):
print(args) #(1, 2, 3, 4, 5)
sumN = 0
for i in args:
sumN += i
return sumN
l1 = [1,2,3]
l2 = [4,5]
sumN = func(*l1,*l2)
print(sumN) #15
#错误实例
l1 = [1,2,3]
def func(*args):
print(args) #([1, 2, 3],)
func(l1) #不加*会将整个列表作为一个元素添加到元组中
#魔法元素(字典)
#将多个字典的键值对合并到一个字典中
def func(**kwargs):
print(kwargs) #{'name1': 'alex', 'name2': 'wusir'}
return kwargs
dic1 = {'name1':'alex'}
dic2 = {'name2':'wusir'}
func(**dic1, **dic2)
#输出结果
{'name1': 'alex', 'name2': 'wusir'}
