精华内容
下载资源
问答
  • python中的参数:形参实参 形参: 形式上的参数,可以理解为数学中的x,没有实际的值,通过别人赋值后才有意义。相当于变量 实参: 实际意义上的参数,是一个世纪存在的参数,可以是字符串或者数字等。 就是在函数...

    python中的参数:形参实参

    形参:

    形式上的参数,可以理解为数学中的x,没有实际的值,通过别人赋值后才有意义。相当于变量

    实参:

    实际意义上的参数,是一个世纪存在的参数,可以是字符串或者数字等。

    就是在函数名中定义一个形参,然后在函数调用的时候,给函数名中的形参传递一个实际的参数,这个就是实参。这样的话执行函数时就会使用参数执行相应的操作。

    def func(a):			#a是形参
         print(a)
     
     func(1)               #1是实参
    #代码运行结果为:1
    

    形参中*的作用:

    def func(a, *args):			
         print(a)
         print(args)
     
     func(1,2,3,4)          
    #把1传给a,把2,3,4传给*args
    

    1、*args是可变参数,args接收的是一个元组;

    2、**kw是关键字参数,kw接收的是一个字典;

    3、在 lambda 表达式中使用 *和 **,lambda 表达式可以当作一个匿名函数。只要是函数都可以传参。

    实参中*的作用

    1、实参中的*号会获取可迭代对象的 key(索引/键值);

    def func(n1, n2, n3, n4, n5):
        return n1, n2, n3, n4, n5
    
    d = {'n1': 5, 'n2': 6, 'n3': 7, 'n4': 8, 'n5': 9}
    print(func(*d))  
    # 打印得到的结果为 ('n1', 'n2', 'n3', 'n4', 'n5')
    

    由于获取的是可迭代对象的 key,所以函数的形参可以为位置参数或可变参数。

    2、实参中的**会获取可迭代映射的值;

    def func(n1, n2, n3, n4, n5):
        return n1, n2, n3, n4, n5
    
    d = {'n1': 5, 'n2': 6, 'n3': 7, 'n5': 8, 'n4': 9}
    print(func(**d))
    # 打印得到的结果为(5, 6, 7, 9, 8)
    

    由于获取的是可迭代对象的值,所以函数的形参只能为关键字参数,即参数的个数和名称都是固定的。

    参数的混合使用:

    1、位置参数和可变参数

    def func(a, *args):
        print(a)
        print(args)
    
    func(1,2,3,4)
    #把1传给a,把2,3,4传给*args
    

    2、位置参数和默认参数

    def func(a, b = 10):
        print(a)
        print(b)
    
    func(1)
    #把1传给a,但是b不变
    

    3、默认参数和可变参数混合使用,默认参数在可变参数的右侧 ,需要用关键字指定参数

    def func(*args, a):
        print(args)
        print(a)
    func(1,2,3,a = 10)
    
    展开全文
  • 形参实参

    2016-07-05 21:06:43
    本文以实例阐述了C++中形参实参的区别,有助于读者加深对于C++形参实参的认识。 形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量...

    本文以实例阐述了C++中形参与实参的区别,有助于读者加深对于C++形参与实参的认识。

    形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也不能使用。 形参和实参的功能是作数据传送。发生函数调用时, 主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送。

    1.形参变量只有在被调用时才分配内存单元,在调用结束时, 即刻释放所分配的内存单元。因此,形参只有在函数内部有效。 函数调用结束返回主调函数后则不能再使用该形参变量。

    2.实参可以是常量、变量、表达式、函数等, 无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值, 以便把这些值传送给形参。 因此应预先用赋值,输入等办法使实参获得确定值。

    3.实参和形参在数量上,类型上,顺序上应严格一致, 否则会发生“类型不匹配”的错误

    4.函数调用中发生的数据传送是单向的。 即只能把实参的值传送给形参,而不能把形参的值反向地传送给实参。 因此在函数调用过程中,形参的值发生改变,而实参中的值不会变化。

    参考如下示例:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    void Exchg1(int x, int y)
    {
     int tmp;
     tmp=x;
     x=y;
     y=tmp;
     printf("Exchg1:x=%d,y=%d\n",x,y);
    }
    void Exchg2(int &x, int &y)
    {
     int tmp;
     tmp=x;
     x=y;
     y=tmp;
     printf("Exchg2:x=%d,y=%d\n",x,y);
    }
    void Exchg3(int *x, int *y)
    {
     int tmp;
     tmp=*x;
     *x=*y;
     *y=tmp;
     printf("Exchg3:x=%d,y=%d\n",*x,*y);
    }
     
    void main()
    {
     int a=4,b=6;
     Exchg1 (a,b) ;
     printf("a=%d,b=%d\n",a,b);
     Exchg2 (a,b);
     printf("a=%d,b=%d\n",a,b);
     Exchg3(&a,&b) ;
     printf("a=%d,b=%d\n",a,b);
    }

    这里Exchg1函数被调用的时候,并没有成功交换a跟b的数据。为何呢。
    int a=4,b=6;
    Exchg1 (a,b) ;   //这里本质上发生的是:Exchg1 (intx=a,int y=b) ;   x跟y是函数定义里面的形参,也就是说这里只是把实参a跟b的值赋予了x,y这2个形参变量。接下来,函数里发生的值互换只换掉了x跟y的值,而实参a跟b没有影响。
    再看Exchg2 (a,b);   //再看本质Exchg2 (int &x=a,int &y=b);   这里x跟y都是a,b的引用,操作x跟y交换就等于a跟b交换,自然,调用Exchg2 可以成功交换a跟b
    Exchg3(&a,&b) ;   //Exchg3(int *x=&a,int *y=&b);   x跟y2个形参是a跟b的指针,也就是实参数据存放的地址。然后函数里交换了x跟y指向的数据,也就是实参a跟b,所以,交换也是成功的。

    代码运行的结果,exchg1没有交换a,b值;exchg2交换了a,b值,到了exchg,a,b的值似乎没有交换,仍旧是a为4,b为6,刚开始以为代码有问题,后来设置了断点之后,发现代码运行到exchg3(&a,&b)时,a=6,b=4了,所以代码运行结果和初始值一样的话,说明已经交换了a,b的值,至此说明代码是没有任何问题的。

    展开全文
  • 随机数及形参实参

    2019-02-22 18:47:16
    随机数: function getRandom(max, min){ var num = Math.floor(Math.random()(max-min+1))...形参实参要一一对应 如果定义形参,没有实参,则 相当于在函数里面第一行var 了一个变量对应形参 形参:声明函数时, 定义...

    随机数
    function getRandom(max, min){
    var num = Math.floor(Math.random()(max-min+1))+min;
    console.log(num)
    }
    Math.floor(Math.random()
    91)+10;
    形参实参要一一对应

    如果定义形参,没有实参,则
    相当于在函数里面第一行var 了一个变量对应形参
    形参:声明函数时, 定义在函数括号中的变量
    * 实参:调用函数时, 传入函数的值

    arguments:实参集,跟数组结构一样 ,但没有数组的功能,是类数组

    return:返回函数的执行结果,没有返回自则返回undefined;

    作用域:
    // 作用域:js代做发挥作用的地方
    // 全局作用域: 一个html中所有script标签合在一起
    // 局部作用域: 函数作用域, 块级作用域(ES6)
    // 作用域链: 当一个局部作用域使用一个变量时, 如果当前作用域有
    // 直接使用, 如果没有向上级作用域查找,知道找到全局作用域如果还没有
    // 报错
    // 结论: 函数可以访问外部的变量, 但是外部不可以访问函数内部的变量;

    // 递归类似循环
    // 函数自己调用自己
    function fn() {
    fn();
    }
    fn();
    // 函数执行完以后,才可以释放内存

        // 死递归会报错, 不会造成浏览器卡死
        // 缺点: 占用内存, 不容易被释放,可能造成内存泄漏, 计算速度越来越慢**加粗样式**
    
    展开全文
  • Python之形参实参详解

    2020-08-26 23:43:16
    Python之形参实参详解 python函数中重要的一部分就是参数的调用,今天对参数进行讲解。 参数大体上分为两种: 形参(形式参数):在定义函数阶段定义的参数称之为参数,粗略的可以认为是变量名。 实参:在调用函数...

    Python之形参实参详解

    python函数中重要的一部分就是参数的调用,今天对参数进行讲解。
    参数大体上分为两种:
    形参(形式参数):在定义函数阶段定义的参数称之为参数,粗略的可以认为是变量名。
    实参:在调用函数阶段传入的值称之为实际参数,简称实参,粗略的可以认为是变量值。
    首先清楚一下几点:
    1.在调用函数阶段,实参会绑定给形参,且这种关系只能在函数体内用,结束后即被收回。
    2.实参被赋予的相当于变量名的地址(后面会有解释)。
    按照作用分又有以下几种:
    1.位置参数:
    1.1位置形参:按照从左往右的顺序依次定义的变量名,且必须被传值,多一个少一个都不行

    def func(x,y):
        print(x*y)
    func(2,3)
    

    1.2位置实参:按照从左往右的顺序依次定义的变量名,一一对应

    def func(x,y):
        print(x*y)
    func(1,2)#2
    func(2,1)#2
    

    2.关键字实参:在函数调用的阶段,按照键值对的方式传入值可以完全不参照顺序,给某个形参传值。

    def func(x,y):
        print(x*y)
    func(x=2,y=3)#6
    func(y=3,x=2)#6
    

    需要注意的是:位置形参可以和关键字实参混合使用,但必须在关键字实参之前:
    错误示范:

    def func(x,y):
        print(x*y)
    func(x=2,3)#SyntaxError: positional argument follows keyword argument
    

    同时还应该避免向用同一个形参传值。
    3.默认形参:在函数定义阶段,就已经被赋值的形参。

    def func(x,y = 3):
        print(x*y)
    func(x = 1,y=2)#2
    

    此时如果给默认参数赋予一个新的值,那么就会覆盖默认值。
    同样位置形参可以和默认形参混用,但需要注意的是:
    (1):位置形参必须在默认形参的左边(可以认为位置形参具有较高的优先级)
    错误示范:

    def func(x =2,y):
        pass#SyntaxError: non-default argument follows default argument
    

    需要注意到一点:默认参数的值是在函数定义阶段被赋予的,被赋予的是值的内存地址。

    m=[1111,]
    def func (x,y=m):
        print(x,y)#1 [1111, 111]
        print(type(y))#<class 'list'>
    m.append(111)
    func(1)
    

    4.可变长度参数(*与**的使用)
    可变长度是指在调用函数时,传入的值(实参)不固定:
    实参是给形参赋值的,所以多余的实参必须要有对应的形参接收:
    4.1位置参数:(*args) 输出类型为元组。
    举例:

    def func(x,y,*z):
        print(x,y,z)
    func(1,2,3,4,5)
    

    这时候对应关系为x:1,y:2,z:(3,4,5)。
    结果为:

    1 2 (3, 4, 5)
    <class 'tuple'>
    

    同时也可以打印列表。

    def func(x,y,*z):
        print(x,y,z)
        print(type(z))
    func(1,2,[3,4,5])
    
    1 2 ([3, 4, 5],)
    <class 'tuple'>
    

    实例:多个数相加:

    def func(*x):   #多个数相加
        res = 0
        for item in x:
            res+=item
        print(res)
    
    func(1,2,3)#6
    

    关键字参数:(**kwargs) 输出为字典。
    举例:

    def func(x,y,**kwargs):
        print(x,y,kwargs)
        print(type(kwargs))#字典
    
    func(1,2,z = 3,c = 4)
    
    1 2 {'z': 3, 'c': 4}
    <class 'dict'>
    

    补充:* 可以用在实参中,实参中带 * ,把*后面的值拆分成实参。
    ex:

    def func(x,y,*z):
        print(x,y,z)
    
    func(*[1,2,3,4])#1 2 (3, 4)
    

    调用过程中把列表拆开分为1,2,3,4 再与定义阶段对应:x:1,y:2,z:(3,4)
    同样的: ** 用在实参中,
    ** 后跟的是字典,把* * 后面的值打散成关键字实参

    def func(x,y,z):
        print(x,y,z)
    func(**{'x':1,'y':2,'z':3})#1 2 3  把字典拆分后输出变量值
    func(*{'x':1,'y':2,'z':3})#x y z  可以理解为*拆分后引用变量名
    

    若形参和实参中都带**:

    def func(x,y,**kwargs):
        print(x,y,kwargs)
    func(**{'x':1,'y':2,'z':3,'v':4})
    
    1 2 {'z': 3, 'v': 4}
    

    调用阶段字典先被拆分,使x对应1,y对应2,后面的关键字参数又被输出为字典重新打印成{‘z’: 3, ‘v’: 4}

    混用* 与**:*args必须在**kwargs之前:
    ex:

    def func(*args,**kwargs):#考虑扩展性
        print(args)
        print(kwargs)
    
    func(1,2,3,x = 1,y = 2,z = 3)
    

    *args的作用应该是使前三个元素输出为元组,后面关键字参数输出为字典

    (1, 2, 3)
    {'x': 1, 'y': 2, 'z': 3}
    

    循环调用:

    def index(x,y,z):
        print("=>>>>>",x,y,z)
    
    def wrapper(a,b,c):
        index(a,b,c)
        print(index)  #循环调用
    
    wrapper(1,2,3)
    

    解释:wrapper调用了1,2,3,并传给wrapper函数体内的index(a,b,c),此时打印index应该是其内存的地址,又触发index函数体

    =>>>>> 1 2 3
    <function index at 0x02CC7FA0>
    

    5.命名关键字参数(了解)
    在定义函数时,*后定义的参数,如下所示称之为命名关键字参数
    特点:
    1.必须按照key =value的形式为其传值

    def func(x,y,*,a,b):#a和b称之为命名关键字参数
        print(x,y)#1 2
        print(a,b)#111 222
    func(1,2,b = 222,a = 111)
    
    def func(x,y,*,a=111,b ):#a和b称之为命名关键字参数  a是给命名关键字参数赋了值
        print(x,y)#1 2
        print(a,b)111 222
    func(1,2,b =222)
    

    6.组合使用:(了解)
    形参顺序:位置形参,默认形参,*args ,命名关键字参数, **kwargs

    def func(x,y = 111,*args,z,**kwargs):
        print(x)
        print(y)
        print(args)
        print(z)
        print(kwargs)
    

    实参顺序:

    def func(x,y,z,a,b):
        print(x)
        print(y)
        print(z)
        print(a)
        print(b)
    func(1,*[1,2],**{'a':11,"b":222})
    

    由于5和6没有实际需求场景,所以用处不太大,仅为了解。
    各位读者大大,走的时候点个赞吧

    展开全文
  • 形参实参 小实例(实参列表 arguments【】) 形参实参映射;不对应的话不会有映射 补充:return 1.终止 2.返回值又终止 return123 递归 switch case string 字符串反转小实例 ...
  • java引用形参实参运行结果
  • c++形参实参

    千次阅读 2013-08-06 11:01:55
    c++形参实参实参和形参,很抽象的一个概念,新手很难搞懂。 形参:全称为"形式参数"是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传递的参数.  形参的作用是实现主调函数与被调函数之间...
  • 形参实参引用传递

    2019-08-13 09:34:56
    Java中的形参实参的区别以及传值调用和传引用调用 参考资料 1,Java实参形参与传值和传引用 https://blog.csdn.net/wanliguodu/article/details/55653876 2,Java中的形参实参的区别以及传值调用和传引用调用 ...
  • 指针形参实参传递时需要注意

    千次阅读 2015-05-30 10:39:48
    指针形参实参传递时需要注意: 主调函数中实参指针传给被调函数的形参指针时,意味着两个指针指向同一块内存单元。这种情况下在被调函数中通过形参指针对内存区进行操作后,极有可能带来两个指针(形参指针和实参...
  • 关于C语言初始化,以及形参实参的一道易错题
  • python形参实参

    千次阅读 2017-01-12 10:50:22
    实参形参 前面定义函数 greet_user() 时,要求给变量 username 指定一个值。调用这个函数并提供这种信息(人名)时,它将打印相应的问候语。 在函数 greet_user() 的定义中,变量 username 是一个形参 —— 函数完成...
  • 本文档是一个实参形参影响的程序的调试过程及结果,可以帮助更好的理解函数实参形参关系
  • 形参 实参 指针

    2020-04-26 23:43:32
    形参 实参 指针 形参 实参 在学习C语言的过程中,大多浅尝辄止,点到为止,所以当有人问起你C语言怎么样,你会尬笑一下,说一句没有底气的话:“”“还行吧”,为了更深入的学习,今天开始记录一些知识点。...
  • 关于c的形参实参与运行时结构 今天突然看到这个程序题,感觉对C语言的遗忘了好多,感觉还是记下来比较好。 首先明确几个概念:1)当程序运行到某个函数模块时,编译器 会为其创建一个单独的运行时空间,这个空间...
  • js 形参 实参 arguments

    2019-09-25 16:11:01
    function test(a,b){ //a,b 形参 console.log(arguments);//[1,2,1,3,5] 实参列表 console.log(test);//2 形参长度 } test(1,2,1,3,5) //1,2,1,3,5实参
  • 基础缺失2、形参实参

    2020-06-09 14:54:09
    一般调用时,只能实参传给形参,不能形参传给实参实参形参在数量上,类型上,顺序上应严格一致, 否则会发生“类型不匹配”的错误。 若函数参数是指针时,函数体内可改变实参的值 :传给函数的是实参的地址,在...
  • 形参 实参 传值问题

    2017-09-18 19:35:40
    虽说这是个老生常谈的问题了 ...只能实参传给形参 形参给不了实参 所以第一个结果输出的是:a 而不是b 第二个结果之所以输出c 是因为直接把a的地址给了test2 的入参  之后相当于直接改的是char a
  • java形参实参

    2016-07-28 10:44:22
    (一)基本数据类型:传值,方法不会改变实参的值。 如int,string ...(1)方法体内改变形参引用,但不会改变实参引用 ,实参值不变。 (2)方法体内,通过引用改变了实际参数对象的内容,注意是“内容
  • vb与vc中的形参实参(笔记)

    千次阅读 2010-09-21 11:49:00
    最近CSDN上看了个帖子,涉及到形参实参的问题,竟然把我都给搞糊涂了。为了加深对编程语言概念的印象,特利用VB与C中对形参实参调用的不同点,来巩固一下基本功。本文档所述均为我自己的体会,许多内容和说法并非...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,069
精华内容 7,227
关键字:

形参实参