Python学习心得第四周-01 函数的参数

1、函数的参数分为两大类：形参与实参
    形参：指的是在定义函数时，括号指定的参数,本质就是变量名
    实参：指的是在调用函数时，括号内传入的值，本质就是值

    只有在调用函数时才会在函数体内发生实参（值）与形参（变量名）的绑定关系
    该绑定关系只在调用函数时临时生效，在调用函数结束后就解除绑定

    def foo(x,y): #x=1，y=2
        print(x)
        print(y)

    # a=1
    # b=2
    # foo(a,b)
    foo(1,2)

2、位置参数：
    位置形参：在定义函数时，按照从左到右的顺序依次定义的形参称之为位置形参
        注意：
            1、但凡是按照位置定义的形参，在调用函数时必须其传值，多一个不行少一个也不行

    位置实参: 在调用函数时，按照从左到右的顺序依次传入的值
        注意：
            1、在传值是按照顺序与形参一一对应

3、关键字实参：
    在调用函数时，按照key=value的形式定义的实参，称之为关键字实参
        注意：
            1、在传值时可以完全打乱顺序，但仍然能指定道姓地为指定的参数传值
            2、可以在调用函数时，混合使用位置实参与关键字实参
                但是位置实参必须跟在关键字实参左边
                并且不能为一个形参重复传值

def foo(x,y,z):
    print(x,y,z)


# foo(1,2)
# foo(1,2,3,4)
# foo(1,2,3)
foo(3,2,1)

def register(name,sex,age):
    print(name)
    print(sex)
    print(age)


register('egon','male',18)
register('male','egon',18)

register('egon','male',18)
register(sex='male',name='egon',age=18)
register('egon',age=18,sex='male')
register(name='egon','male',age=18)
register('male',name='egon',age=18)
register('egon',age=18,sex='male')

4、默认参数：
    在定义函数时，就已经为某些参数绑定值，称之为默认参数
    注意：
        1、在定义阶段就已经有值，意味在调用阶段可以不用为其传值
        2、默认形参必须放到位置形参的后面
        3、默认形参的值只在定义阶段生效一次，在函数定义之后发生的改动无效
        4、默认形参的值通常应该是不可变类型

    默认形参vs位置形参：
        默认形参：大多数情况下值都一样
        位置形参：大多情况值都是不一样的

def foo(x,y,z=3):
    print(x)
    print(y)
    print(z)

foo(1,2)
foo(1,2,4)

#
def register(name,age,sex='female'):
    print(name)
    print(sex)
    print(age)

register('wxx',38)
register('lxx',48)
register('cxx',28)
register('alex',73,'male')


#
m=10
def foo(x,y,z=m):
    print('x:%s' %x)
    print('y:%s' %y)
    print('z:%s' %z)
m=1111111111111111111111111111111111111111111111111111111111111111
foo(1,2)

#
def foo(name,hobby,l=[]):
    l.append(hobby)
    print('%s 的爱好是 %s' %(name,l))

foo('egon','read')
foo('alex','吹牛逼')
foo('lxx','腰子汤')

#
def foo(name,hobby,l=None):
    if l is None:
        l=[]
    l.append(hobby)
    print('%s 的爱好是 %s' %(name,l))

l1=[]
foo('egon','read',l1) #l1=['read']
foo('egon','music',l1)  #l1=['read','music']
foo('egon',' 吟诗',l1)
# foo('alex','吹牛逼')
# foo('lxx','腰子汤')

5、可变长度的参数：
    可变长度指的是在调用函数时，函数参数的个数可以不固定

    然而实参终究是要为形参传值的，针对两种形式实参个数不固定，对应着形参也必须有两种解决方案*、**
    来分别处理溢出位置实参与溢出的关键字实参


1、* 会将溢出的位置实参存成元组，然后赋值给紧跟其后的变量名
1.1 形参中带*

def foo(x,y,*z): #z=(3,4,5,6,7,8)
    print(x)
    print(y)
    print(z)

foo(1,2,3,4,5,6,7,8)

1.2 形参中带*，实参中带*, 窍门：但凡碰到实参中带*，都先将其打散成位置实参，然后考虑传值

def foo(x,y,*z): #z=(3,4,5,6,7,8)
    print(x)
    print(y)
    print(z)

foo(1,2,[3,4,5,6,7,8]) #z=([3,4,5,6,7,8],)
foo(1,2,*[3,4,5,6,7,8]) #foo(1,2,3,4,5,6,7,8)====>z=(3,4,5,6,7,8)
foo(1,2,*'hello') #foo(1,2,'h','e','l','l','o')
foo(1,*[2,3,4,5,6])  #foo(1,2,3,4,5,6)

1.3 实参中带*, 窍门：但凡碰到实参中带*，都先将其打散成位置实参，然后考虑传值

def foo(x,y,z):
    print(x,y,z)

foo(1,2,3)
foo(l[0],l[1],l[2])

l = ['egon', 'alex', 'lxx']
foo(*l) # foo('egon','alex','lxx')
foo(*[1,2,3,4,5]) #foo(1,2,3,4,5)

** 会将溢出的关键字实参存成字典，然后赋值给紧跟其后的变量名

1.1 形参中带**
def foo(x,y,m,n,**z): #
    print(x)
    print(y)
    print(m)
    print(n)
    print(z)

foo(1,2,n=10,m=20,a=1,b=2,c=3)

1.2 形参中带**，实参中带**, 窍门：但凡碰到实参中带**，都先将其打散成关键字实参，然后考虑传值

def foo(x,y,**z): #
    print(x,y,z)

foo(1,2,**{'a':1,'b':2,'c':2}) #foo(1,2,c=2,a=1,b=2)
foo(1,**{'a':1,'b':2,'c':2,'y':111}) #foo(1,c=2,a=1,b=2,y=111)

　　

1.3 实参中带**,

def foo(x,y,z):
    print(x,y,z)
# foo(1,**{'a':1,'b':2,'y':111,'z':222}) #foo(1,b=2,a=1,y=111,z=222)
# foo(1,**{'y':111,'z':222}) #foo(1,y=111,z=222)
foo(**{'z':1,'y':2,'x':3}) #foo(y=2,z=1,x=3)

如果我们的需求是
需要将外层的函数的参数格式原方不动地转嫁给器内部调用的函数，就需要用到下述形式

def index(name,age,sex):
    print('name:%s age:%s sex:%s' %(name,age,sex))


def wrapper(*args,**kwargs): #args=(1,2,3), kwargs={'a':10,'b':20,'c':30}
    # print(args,kwargs)
    index(*args,**kwargs)
    #index(*(1,2,3),**{'a':10,'b':20,'c':30}) #index(1,2,3,a=10,b=20,c=30)

# wrapper(1,2,3,a=10,b=20,c=30)

我们虽然调用的是wrapper函数，但是我们遵循的其实是index函数的参数规则

def index(name,age,sex):
    print('name:%s age:%s sex:%s' %(name,age,sex))

def wrapper(*args,**kwargs): #args=('egon',), kwargs={'sex':'male','age':18}
    index(*args,**kwargs)
    # index(*('egon',),**{'sex':'male','age':18})
    # index('egon',sex='male',age=18)


wrapper('egon',sex='male',age=18) #

命名关键字参数(了解)：但凡是在*后**之前定义的参数称之为命名关键字参数
注意点：
在调用函数时，传值的形式必须是key=value

def foo(x,y,*args,m=1,n):
    print(x,y,m,n)
    print(args)


# foo(1,2,n=3,m=4)
# foo(1,2,n=3)

foo(1,2,3,4,5,n=222,m=11)

常用形式

def foo(x,y=100,*args,m,**kwargs):
    print(x,y,args,m,kwargs)


foo(1,2,3,4,5,6,m=200,n=300,a=400)

def foo(x,y):
    pass

def foo(x,y=1):
    pass

#
def wrapper(*args,**kwargs):
    index(*args,**kwargs)



def foo(x,*args):
    pass

def foo(x,**wkargs):
    pass

def foo(x,y,*args,**kwargs):
    pass

#
def my_sum(*args):
    res=0
    for item in args:
        res+=item

    return res

print(my_sum(1,2,3,4,5,6))