zoukankan      html  css  js  c++  java
  • day14 参数

    一、参数介绍

    形参:在定义函数阶段定义的参数成为形式参数,简称形参,相当于变量名

    实参:在调用函数阶段传入的值称之为实际参数,简称实参,相当于变量值

    形参和实参的关系:

    ​ 在调用阶段,实参(变量值)会绑定给形参(变量名)

    ​ 这种绑定关系只能在函数体内调用

    ​ 实参和形参的绑定关系在函数体调用时生效,函数调用结束解除绑定关系

    二、形参与实参的具体使用

    2.1位置参数

    定义:按照从左到右的顺序依次定义的参数称之为位置参数

    位置形参:在函数定义阶段,按照从左到右的顺序直接定义的“变量名”

    特点:必须被传值,不能多也不能少

    位置实参:在函数调用阶段,按照从左到右依次传入值

    特点:按照顺序和形参一一对应

    2.2关键字参数

    关键字实参:在调用阶段,按照key=value的形式传入的值

    特点:指名道姓的传给某个形参值,可以完全不按照顺序

    2.3关键字实参和位置实参混合使用时

    强调1:位置实参必须放在关键字实参前

    def foo(x,y):
        print(x,y)
    foo(x=1,2)#错误示范
    foo(1,y=1)#正确示范
    

    强调2:不能为同一个形参重复传值

    2.4默认参数

    默认形参:在定义阶段,就已经给形参赋值

    特点:在定义阶段就已经给他赋值了,在调用阶段可以不给他传值(非要传也可以)

    如果在一个函数内,某一个形参他的值在绝大部分都是不变的,就可以用到默认参数

    def foo(name,age,sex="male"):
        print(name,age,sex)
    foo("hz",18)
    foo("lxt",19)
    foo("egon",1,sex="flame")
    

    2.5位置形参和默认形参混用

    强调1:位置形参必须在默认形参前

    强调2:默认参数的值是在函数定义阶段被赋值的,准确的说被赋予的是内存地址的值此处区别可变与不可变类型,虽然用可变类型不会报错,但是默认不使用可变类型作为参数

    #不可变类型
    m=11
    def foo(x,y=m):
        print(x,y)
    m=12
    foo(1)
    >>>1 11
    
    #可变类型
    n=[123,]
    def fpp(x,y=n):
        print(x,y)
    n.append(456)
    fpp(1)
    >>>1 [123, 456]
    

    强调3:函数的理想状态,函数的调用只跟函数有关,不受外界代码影响

    def loo(a,b,c,l=None):
        if l is None:
            l=[]
        l.append(a)
        l.append(b)
        l.append(c)
        print(l)
    n = [222]
    loo(1,2,3,n)
    >>>[222, 1, 2, 3]
    

    2.6 可变长度的参数(*与**用法)

    可变长度是指在调用函数时,传入的值(实参)的个数不固定

    而实参是用来给形参定义的,所以需要有一个对应的参数去接受那些溢出的实参

    2.6.1可变长度的位置参数

    第一类:*参数名:用来接受溢出的位置实参,

    溢出的位置实参都会被*保存成一个元组格式然后赋值给这个参数名,约定俗成这个参数名为args

    def foo(*args):
        print(args)
    foo(1,2,3,4,5,6,4,7,)
    >>>(1, 2, 3, 4, 5, 6, 4, 7)
    

    第二类:*在实参中,会把这后面的值全部打散成位置实参,可以被for循环遍历的都可以放在这里

    def foo(a,b,c):
        print(a,b,c)
    foo(*(1,2,3))
    >>>1 2 3
    

    2.6.2可变长度的关键字参数

    第一类:**形参名:用来接受溢出的关键字实参,可以将溢出的关键字实参都保存成字典的格式,然后赋值给后面的参数名,约定俗成是kwargs

    def foo(a,b,**kwargs):
        print(a,b,kwargs)
    foo(1,2,x=1,xx=2,xxx=3)
    >>>1 2 {'x': 1, 'xx': 2, 'xxx': 3}
    

    第二类:**实参(只能是字典格式),会把这个实参打散成关键字实参

    def foo(a,b,):
        print(a,b)
    foo(**{"a":1,"b":2})
    >>>1 2
    

    混用实例

    #注意:在混用时,*args必须在*kwargs之前
    def func(x,*args,**kwargs):
        print(args)
        print(kwargs)
    func(1,2,3,4,5,6,7,8,y=2,z=3)
    >>>(2, 3, 4, 5, 6, 7, 8)
    >>>{'y': 2, 'z': 3}
    

    特殊混用实例

    def index(x,y,z):
        print('index=>>> ',x,y,z)
    
    def wrapper(*args,**kwargs): #args=(1,) kwargs={'z':3,'y':2}
        index(*args,**kwargs)
        # index(*(1,),**{'z':3,'y':2})
        # index(1,z=3,y=2)
    
    wrapper(1,z=3,y=2) # 为wrapper传递的参数是给index用的
    
  • 相关阅读:
    人脸识别的一些网站
    41、过滤驱动程序
    13、ActiveX控件
    42、驱动程序调试
    20、宽字符串与字符串间的相互转换
    14、HOOK和数据库访问
    43、Windows驱动程序模型笔记(一)
    7、注册表读写的一个例子
    12、动态链接库,dll
    40、总结IRP,handling IRPs,Part II
  • 原文地址:https://www.cnblogs.com/hz2lxt/p/12519359.html
Copyright © 2011-2022 走看看