Python入门之函数-2

时间:2022-05-21 20:03:30

 本篇目录:

    一、 函数参数之形式参数与实参

    二、 函数参数的具体使用

 

#1、位置参数:按照从左到右的顺序定义的参数
        位置形参:必选参数
        位置实参:按照位置给形参传值

#2、关键字参数:按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题:
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数:形参在定义时就已经为其赋值
        可以传值也可以不传值,经常需要变得参数定义成位置形参,变化较小的参数定义成默认参数(形参)
        注意的问题:
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型

#4、可变长参数:
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义,针对这两种形式的可变长,形参对应有两种解决方案来完整地存放它们,分别是*args,**kwargs

#5、命名关键字参数:*后定义的参数,必须被传值(有默认值的除外),且必须按照关键字实参的形式传递

 

==========================================================================

 

一、函数的形式参数和实参

 

1. 形式参数:定义函数时,括号内定义的参数,其实就是变量名,
  
  # x,y就是形式参数
    def func(x,y):
    pass

 

  2. 实际参数:调用函数是,括号内由外部调用者传入的值,其实就是变量值,

 
# 10,11就是实参

     func(10,11)
'''
注意点
实参值(变量的值)和形参(变量名)的绑定关系只有在函数调用时才会生效
函数调用结束后,就会失效,解除绑定,释放资源
'''

 

二、 函数参数的具体使用

 

  1.位置参数

 

    1.1 位置参数,位置即顺序,位置参数就是按照从左到右的顺序依次定义的参数

 

    1.2 在定义函数阶段,按照位置定义的形式参数,称为位置形参

    

def foo(x,y,z):
    print(x,y,z)
# 位置形参必须为其传值,有几个形参,必须传入几个值

 

    1.3 在调用函数的阶段,按照位置定义的实参,被称位置实参

 

#1,2,3都是位置实参

foo(1,2,3)
........

 

  2. 关键字参数(属于位置实参

 

    2.1 在调用函数的时候,按照key=value的形式定义的实参,称为关键字参数

 

      a. 相当于指名道姓的为形参传值,意味着不按照顺序定义,礽可以为参数传值

 

foo(1,2,3)
foo(y=2,x=1,z=3)

 

      b. 调用函数时,位置实参与关键字可以混合使用,但是必须满足传值的要求

    

# 必须遵循形参的规则
foo(x,y,z)
foo(1,z=3,y=2)
# 不能为同一个形惨重复传值
foo(x,y,z)
foo(1,x=1,z=3,y=2)

 

  3. 默认参数

 

    3.1 在函数定义阶段,已经为某个形参赋值,该形参被称为默认参数

    

# 注意在函数定义阶段已经有值,意味着调用阶段可以不用传值
# 如果传值,那就覆盖默认参数
def register(name, age, gender='male'):
    print(name, age, gender)

register('Archer, 20)
register('Bob, 22)
register('Carol‘, 27,'Female')
# 对于经常需要变化的值,需要将对应的形参定义为位置形参
# 对于大多数情况下,值都一样,可以将对应的形参定义为默认参数

 

    3.2 位置形参必须在默认参数前面

 

# 错误参数放置
def func(y=1,x):
    pass

#正确参数放置

def func(x, y=1):
    pass

 

    3.3 默认参数的值只在定义阶段赋值一次,也就是说默认参数的值在定义阶段就被固定

 

# 函数定义阶段

m=10
def foo(x,y=m):
    print(x,y)


#函数调用阶段(即使这时候m变为11,但是函数调用后还是打印 1,10)
m=11
foo(1,m)
# 以上的打印结果
1 10

# 不会是 1 11

 

    3.4 默认参数的值应该设置为不可变类型

 

def register(name, hobboy, l=[]):
    l.append(hobby)
    print(name, l)

register('Archor', 'reading')
register('Alen','running')
register('Bob','playing')
#以上的打印结果
Archor reading
Alen reading  running
Bob reading running playing

# 不是很奇怪吗?我们要分别打印出姓名+爱好,但是结果来看,爱好被堆积起来传递下去了
# 这是因为默认参数的值我们定义为了一个空列表,列表是个可变类型(可以改变里面的值,列表的内存地址不变,这是可变类型的特点)
# 如果默认参数被传值的话,就会覆盖原值,可以通过每次都覆盖的方式来改进上面的程序
def register(name, hobby, l=[])
    l.append(hobby)
    print(name,l)

# 这里我们自带了空列表来覆盖每次产生的新值
register('Archor', 'reading', [])
register('Alen', 'running', [])
register('Bob', 'playing', [])
#以上的打印结果
Archor reading
Alen running
Bob playing
# 当然我们也可以通过把默认参数直接设置为None来改进
def register(name, hobby,l=None):
    if l is None:
        l=[]
        l.append(hobby)
    print(name,l)

register('Archor', 'reading')
register('Alen', 'running')
register('Bob', 'playing')

register('Archor', 'reading', [])
register('Alen', 'running', [])
register('Bob', 'playing', [])
# 上面的输出结果为

Archor ['reading']
Alen ['running']
Bob ['playing']
Archor []
Alen []
Bob []

#这里请多加对比思考

  

  4. 可变长度类型的实参(*args, **kwargs)

 

    4.1 实参的个数可以不固定

 

      a. 按照位置定义的实参

      b. 按照关键字定义的实参

 

    4.2 (*args)可以将溢出位置的实参全部接收,然后保存成元组的形式返回给args

 

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

foo(1,2,3,4,5,6,7,8,)
# 以上的返回结果为
1 2 3
(4,5,6,7,8,)

 

    4.3 (**kwargs)可以将溢出位置的实参全部接收,然后保存成字典的形式返回给kwargs

 

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

foo(x=1,y=2,z=3,a=1,b=2,c=3)
#以上的返回结果为
1 2 3'a':1,'b':2,'c':3}

 

    4.4 如果遇到实参带*,那么就需要拆分该实参

 

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

foo(*[1,2,3])
foo(*(1,2,3))
foo(1,2,3,*{'a':1,'b':2})
foo(1,2,3,*'canshu')
# 以上的输出结果

1 2 3
()

1 2 3
()

1 2 3
('a', 'b')

1 2 3
('c', 'a', 'n', 's', 'h', 'u')

 

    4.5 如果遇到实参带**,那么就需要拆分该实参

 

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

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

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)