函数：执行特定任务和完成特定功能的一段代码
def 函数名([输入参数]) :
def calc(a,b): #a b两个占位符，占两个数据的位置
c=a+b #函数体(函数定义处)，a+b的结果存放在c当中
return(c) #结束这个函数，同时将结果提交给函数的调用处
result=calc(10,20) #谁去提交
print(result) #30
函数的参数传递 ：
- 位置实参
- 关键字实参
#函数的参数传递
#位置实参(一个萝卜一个坑)
def calc(a,b): #形式参数，形参的位置是在函数的定义处
c=a+b
return(c) #
result=calc(10,20) #实际参数，实参的位置是在函数的调用处
print(result) #30
#关键字实参
res=calc(b=10,a=20) #根据=左侧的变量的名称称为关键字
print(res) #30
函数参数传递的内存分析
def fun(arg1,arg2):
print('arg1',arg1)
print('arg2',arg2)
arg1=100
arg2.append(10)
print('arg1',arg1)
print('arg2',arg2)
#return
n1=11
n2=[22,33,44]
fun(n1,n2) #位置传参，arg1，arg2是函数定义出的形参，n1，n2是函数调用处的实参
#总结：形参名和实参名可以不相同
print('n1',n1) #n1 11
print('n2',n2) #n2 [22, 33, 44, 10]
#！函数体不会修改实参的值
总结：
在函数调用过程中,进行参数的传递
如果是不可变对象(字符串，元组),在函数体的修改不会影响实参的值//arg1的修改为100,不会影响n1的值
如果是可变对象(列表，字典，集合),在函数体的修改会影响实参的值//arg2的修改 append(10) 会影响到n2的值
函数的返回值
#函数的返回值
#1)如果函数没有返回值【函数执行完之后，不需要给调用处提供数据】，return可以省略不写
#2)函数的返回值，如果是1个，直接返回原值（原类型）
#3)函数的返回值如果是多个，则返回的结果是元祖。
def fun1():
print('hello')
fun1() #hello
def fun2():
return 'hello'
res=fun2()#函数的调用，对这个数进行存储
print(res) #hello
def fun3():
return 'hello','world'
print(fun3()) #('hello', 'world') 得到一个元祖
#函数在定义时，是否需要返回值，视情况而定。
#所有对象都有布尔值
print(bool(0)) #False
print(bool(1)) #非0的布尔值为True
print(bool(2))
def fun(num):#使用def定义一个函数，叫fun，传入一个行参叫num
odd=[] #一个列表存奇数
even=[] #一个列表存偶数
for i in num: #用i去遍历这个列表
if i%2: #如果i与2的余数的布尔值为true，则为奇数
odd.append(i)
else:
even.append(i)
return odd,even
#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst)) #调用这个函数，把列表传进去，然后对结果(函数的返回值)进行输出
#([29, 23, 53, 55], [10, 34, 44]) 得到一个元祖，第一个元素是奇数列表，第二个元素是偶数列表
函数的参数定义
#默认值参数 输出结果默认换行
#函数的参数定义
def fun(a,b=10): #b称为默认值参数
print(a,b)
#函数的调用
fun(100) #100 10
fun(20,30) #20 30 30直接替补了10
#个数可变的位置形参,个数可变的关键字形参
#函数的参数定义，个数可变的位置形参，个数可变的关键字形参
def fun(*a): #a为变量名,可变的位置参数（按顺序传,传多少都可以）
print(a)
#print(a[0])
#函数调用
fun(10) #(10,)
fun(10,30) #(10,30)
fun(10,40,50) #(10,40,50)
#个数可变的关键字形参
def fun1(**a):
print(a)
fun1(a=10) #{'a': 10}
fun1(a=10,b=20,c=30) #{'a': 10, 'b': 20, 'c': 30}
#在函数的定义中，个数可变的位置函数（关键字参数）只能有一个
def fun(*a1,**a2):
pass
#在一个函数的定义中，既有个数可变的关键字形参，也有个数可变的位置形参，
# 要求个数可变的位置形参放在个数可变的关键字形参之前。
函数的参数总结
1)函数调用时的参数传递
#1)函数调用时的参数传递
def fun(a,b,c):
print('a=',a)
print('b=',b)
print('c=',c)
#函数调用
fun(10,20,30) #函数调用时的参数传递，称为位置传参
#a= 10 b= 20 c= 30
lst=[11,22,33]
fun(*lst) #加*，在函数调用时，将列表中的每个元素都转换为位置实参传入
#a= 11 b= 22 c= 33
fun(a=100,b=200,c=300) #函数的调用，关键字参数
#a= 100 b= 200 c= 300
dic={'a':111,'b':222,'c':333}
fun(**dic) #函数调用时，将字典中的每个元素都转换为关键字实参
#a= 111 b= 222 c= 333
#2）函数定义时的参数传递
#2）函数定义是的参数传递
def fun(a,b=10): #b称为默认值形参，且给了赋值
print('a=', a)
print('b=', b)
def fun2(*arges): #个数可变的位置形参
print(arges)
def fun3(**arges2): #个数可变的关键字形参
print(arges2)
#函数的调用
fun2(10,20,30,40) #(10, 20, 30, 40) 结果为元祖
fun3(a=11,b=22,c=33,d=44,e=55) #{'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55}
3)关键字形参
def fun4(a,b,*,c,d): #从*之后的参数，在函数调用时，只能采用关键字实参传递
print('a=',a)
print('b=',b)
print('c=',c)
print('d',d)
#调用函数
#fun4(10,20,30,40) #位置实参传递 a=10 b=20 c=30 d=40
fun4(a=11,b=22,c=33,d=44) #关键字实参传递 a=11 b=22 c=33 d=44
fun4(11,22,c=33,d=44) #前俩个采用实参，后俩个采用关键字实参
#需求c，d只能采用关键字实参
#函数定义时的形参的顺序问题
def fun5(a,b,*,c,d,**arges): #c，d采用关键字实参，**个数可变的关键字实参
pass
def fun6(*arges,**arges2): # *个数可变的位置实参
pass
def fun7(a,b=10,*args,**args2):
pass
