函数的创建和调用

结构

def 函数名 ([输入参数])：
    函数体
    [return xxx]

print('----函数的创建---')
def calc (a,b):
    c=a+b
    return c #函数的结果给调度处 一般的结果会传递给变量

result=calc(10,30)
print(result)

函数的参数传递

print('----函数的创建---')
def calc (a,b):     #a和b占用了两个实际值的位置 ---所以是形参 ，形参的位置在函数的定义处
    c=a+b
    return c #函数的结果给调度处 一般的结果会传递给变量

result=calc(10,30) #10 30 称为实际参数的值。简称实参 实参出现的位置是函数的调度处
print(result)

参数传递的方式

位置传参：实参的第一个位置传递给了形参的第一个位置

实参1，实参2

关键字传参：（赋值名称参数相同的参数）

形参名称=实参，

print('----函数的创建---')
def calc (a,b):     #a和b占用了两个实际值的位置 -------所以是形参 ，形参的位置在函数的定义处
    c=a+b
    return c #函数的结果给调度处 一般的结果会传递给变量
#根据=左侧的变量传参
#=左侧的变量名称 称为关键字参数
result=calc(b=10,a=30)#10 30 称为实际参数的值。简称实参 实参出现的位置是函数的调度处

print(result)

在函数调用过程中，进行参数传递

如果是不可变对象，在函数体的修改不会影响实参的值

如果是可变对象，在函数体中的修改会影响到实参的值

def fun (arg1,arg2): #是函数定义处的参数是形参
    print('arg1',arg1)
    print('arg1',arg2)
    arg1=100
    arg2.append(10)
    print('arg1:',arg1)
    print('arg2:',arg2)

n1=11
n2=[22,33,44]
print( 'n1:',n1)
print('n2:',n2)
'''
在函数调用过程中，进行参数传递
如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，在函数体中的修改会影响到实参的值
'''
fun(n1,n2)#位置传参 n1 n2是函数调用处的实参

print( 'n1:',n1)
print('n2:',n2)

返回值（函数返回多个值时候，结果为元组）

函数的返回值：
如何函数没有返回值--函数执行完毕后不需要给调度处提供数据 return可以不写
函数的返回值如果是一个--直接就是返回类型 
函数的返回值如果是多个，返回的结果为元组

def fun (num): #是函数定义处的参数是形参
    odd=[]#空列表 存奇数
    even=[]#空列表 存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even

lst=[10,29,34,23,44,53,55]
'''
函数的返回值：
如何函数没有返回值--函数执行完毕后不需要给调度处提供数据 return可以不写
函数的返回值如果是一个--直接就是返回类型 
函数的返回值如果是多个，返回的结果为元组
'''
def fun1():
    print('hello')
def fun2():
    return 'hello'
def fun3():
    return 'hello','world'

print(fun(lst))#得到了元组
fun1()
res=fun2()
print(res)
res=fun3()
print(res)

'''函数在定义时候 是否需要返回值 视情况而定'''

 函数的形参定义（给形参传递参数时：只有实参与默认值不符合才需要传递）

def fun(a,b=10):#b=10为默认值参数
    print(a,b)

fun(100)
fun(20,30)

在实际应用中 可以传递实参的值用来修改形参的默认值

print('hello')#print函数的默认值是\n换行
print('world')
print('hello',end ='\t')#修改为\t 
print('world')

个数可变的位置参数

定义参数时
无法事先确定传递位置参数的个数，使用可变的位置参数 
*用于定义可变的位置参数
结果为一个元组

'''
定义参数时
无法事先确定传递位置参数的个数，使用可变的位置参数 
*用于定义可变的位置参数
结果为一个元组
'''
def fun(*args):
    print(args)

fun(10)
fun(15,20)
print(19,20,30)

'''
def fun(*args,*b):错误 个数可变的位置参数只能是一个
'''

 个数可变的关键字形参

定义参数时
无法事先确定传递关键字实参的个数，使用可变的关键字形参
**用于定义可变的位置参数
结果为一个字典

'''
定义参数时
无法事先确定传递关键字实参的个数，使用可变的关键字形参
**用于定义可变的位置参数
结果为一个字典
'''
def fun(**args):#args是关键字
    print(args)

fun(a=10) #a是关键字
fun(a=30,b=56) #输出是字典

'''
def fun(**args,**b):错误 个数可变的关键字置参数只能是一个
'''

同时存在个数可变的位置参数和个数可变的关键字参数

同时存在个数可变的位置参数 和个数可变的关键字参数
要求：
个数可变的可变的位置参数 在个数可变的关键字形参之前

'''
同时存在个数可变的位置参数 和个数可变的关键字参数
要求：
个数可变的可变的位置参数 在个数可变的关键字形参之前

'''

def fun1(*a,**b):
    pass

'''

程序报错
def fun2(**c,*a):
    pass
'''

总结

（函数调用的参数传递）

def fun(a, b, c):
    # abc是形参--在函数定义处
    print('a=',a)
    print('b=',b)
    print('c=',c)

fun(10, 20, 30) # 函数调用时候的参数传递，称为位置传参----一个一个传递
print('--------------')
lst=[11, 22, 33] #列表的位置传参
# fun(lst) 函数报错 只传递来了一个参数
fun(*lst)  #在函数调用时 将列表中的每一个元素都转换为位置实参传入
print('--------------')
fun(a=100,c=200,b=90) #关键字传参
print('--------------')
dic={'a':100, 'c':34, 'b':35} #字典中的关键字传参
fun(**dic)

总结

（函数定义的参数传递）

def fun(a, b=10):
    # ab--在函数定义处 ab是形参 且进行了赋值 所以b称为默认值传参
    print('a=', a)
    print('b=', b)

def fun1(*args):
    # 个数可变的位置传参 输出的结果是列表
    print(args)
def fun2(**args):
    # 个数可变的关键字形参
    print(args)
print('-----------')
fun(10)
fun(20,90)
print('-----------')
fun1(2,5,6,8,1) #输出为列表
print('-----------')
fun2(张三=9, 李四=0, a=2, 字典='你') #输出是字典 键=值

def fun3(a,b,c,d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
fun3(1,2,3,4) #位置实参传递
print('-----------')
fun3(a=10,b=7,c=4,d=90) #关键字实参传递
print('-----------')
fun3(10,7,c=4,d=90) #前两个参数是位置实参传递 后两个采用的是关键字实参传递

'''需求 c d只能采用关键字传递'''
def fun4(a,b,*,c,d): #*之后的的参数 在函数调用的时候 采用关键字传参
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
#fun4(1, 2, 3, 4)  # 位置实参传递 ab没有采用关键字
print('-----------')
fun4(a=10, b=7, c=4, d=90)  # 关键字实参传递
print('-----------')
fun4(10, 7, c=4, d=90)  # 前两个参数是位置实参传递 后两个采用的是关键字实参传递

函数定义时候形参的顺序问题

'''函数定义时候形参的顺序问题'''
'''
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**args2):
    pass
'''
def fun5(a,b,*,c,d,**args):
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
    print('args=',args)
fun5(10,20,d=5,c=6,e=1,李四=2,吗='王二')
print('---------------')
def fun6(*args,**args2):
    print('args',args)
    print('args2',args2)
fun6(10,50,65,80,7,a=10,老王=80,老李='80')
print('---------------')
def fun7(a,b=10,*args,**args2):
    print('a=', a)
    print('b=', b)
    print('args', args)
    print('args2', args2)
fun7(50,f=10,老王=80,老李='80')
fun7(50,8,9,5,f=10,老王=80,老李='80')