精华内容
下载资源
问答
  • python为了简化函数的调用,提供了默认参数机制: 这样在调用pow函数时,就可以省略最后一个参数不写: 在定义有默认参数函数时,需要注意以下: 必选参数必须在前面,默认参数在后; 设置何种参数默认参数?...
  • 在javascript中如何为函数设置默认参数值,下面提供几种方法供大家参考。 第一种方法: function example(a,b){ var a = arguments[0] ? arguments[0] : 1;//设置参数a的默认值为1 var b = arguments[1] ? ...
  • C/C++支持可变参数个数的函数定义,这一点与C/C++语言函数参数调用时入栈顺序有关,首先引用其他网友的一段文字,来描述函数调用,及参数入栈: ———— 引用开始 ———— C支持可变参数的函数,这里的意思是C支持...
  • c语言中函数参数处理顺序 下面我们来看2个案例,分析下c语言中函数参数处理顺序。 第一个: #include "stdio.h" void fn(int a,int b,int c) { printf("%d,%d,%d", a, b, c); } void main() { int a = 3; ....

    c语言中函数参数处理顺序

    下面我们来看2个案例,分析下c语言中函数参数处理顺序。

    第一个:

    
           #include "stdio.h"
          void fn(int a,int b,int c)
          {
          printf("%d,%d,%d", a, b, c);
          }
          void main()
          {
          int a = 3;
          fn(a++, a++, a++);
          }
    

    输出结果:

    5,4,3

    原因分析:

    C函数参数作为一个整体执行的顺序是从右向左,所以会先处理最右端的参数,然后依次向左处理。所以结果为最右端的a++先被处理结果为3,然后++,接着4和5,这样就有了上面的结果。

    第二个:

     #include
     int main(void)
     {
     int i = 0;
     printf("%d,%d,%d,%d,%d\n", ++i, ++i, i++, ++i, i++);
     }
    

    输出结果:

    5,5,2,5,0

    原因分析:

    和上面的一样,执行的顺序是从右向左,所以会先处理最右端的参数,然后依次向左处理。不同是出现了++i,对于i++和++i是先加与后加的区别,但是在参数处理上则对应。如果是i++那么表示符合从右向左处理的前提下,当即处理该参数。如果是++i,那么表示只是执行++i运算并不将结果作为参数结果,将参数位置压入堆栈,只有当所有参数从右向左处理完毕之后,从堆栈弹出所有因为延后操作语句而没有填入最终结果的参数位置,将最终执行的结果i,作为相应的参数值,填入进去。

    现在大家回忆下,逗号运算符,逗号运算的结合性是从左至右,完毕之后整个表达式的值是最后一个表达式的值。

    例子:

    int a[2],x=2,y=5;

    a[0]=(x+3,y++,x++);

    那么最终结果是:

    a[0]=2 x=3 y=6;

    从上面分析可以看出,函数参数和逗号运算符的执行顺序正好相反!

    注意:

    但是这两个的执行顺序是不确定的。如果函数参数是普通的表达式那么他们的执行顺序是不确定的。这就是为什么我们要避免写 printf("%d%d",++i,i++);这样的垃圾代码了。
    并且C++标准是没有规定的,参数压栈顺序取决于编译器的,看你用什么编译器,貌似VC同GCC的压栈顺序就是相反的,最好在外面算好了再作为参数传递

    C语言函数参数默认原则

    #include <iostream>
    
    int print(int a = 1, int b = 2); 
    
    int main() {
        print();
        print(-1);
        return 0;
    }
    
    //int print(int a = 1, int b = 2) {// 编译错
    int print(int a, int b) {
        std::cout << a << "," << b << std::endl;
    }
    

    结果:

    1,2
    -1,2
    

    首先看上述的代码,print函数是带有默认参数的。

    所以调用print(), print(-1)都可以准确的输出。

    这种默认参数的情况会带来有些便利。(比如初始化一个商品对象,在99%的情况在都是正常的,那么这个商品是否正常的标记就可以默认为1,特殊的1%情况,再加上)

    但是有以下三个要注意的情况。

    1. 默认参数只能放在函数声明处或者定义处,能放在声明处就放在声明处 。
      上述代码把那行注释打开,默认参数在声明和定义处都有了,那么就会有编译错误。(两次默认赋值是不被允许的。)

    2. 大部分情况,别人调用你的代码只能看到函数声明,如果你写在定义处,别人根本不知道你的默认参数是什么。

    3. 如果你是在定义处写的默认参数,那么你在使用该函数前就需要把函数定义放在前面。不然编译阶段通过无默认参数的函数声明无法确定这个函数是带默认参数的。

    所以,默认参数写在声明处啊。^ ^

    2.如果某个参数是默认参数,那么它后面的参数必须都是默认参数

    因为非默认参数的参数必须要给出具体值,而调用函数传递参数的时候是从左到右的,所以非默认参数前面的都必须要传值进来。
    那么默认参数后面的当然也得都为默认参数。

    3.不要重载一个带默认参数的函数

    看下这个函数:

    class Test
    {
    public:
        int func(int a)
        {
            return a;
        }
       int func(int a, int b = 1)
        {
            return a + b;
        }
    } ;
    

    你调用func(1)的时候,谁知道你想调用哪一个。
    更多C++相关知识体系,请移步C++知识目录

    展开全文
  • 形参(函数定义时):普通参数(位置参数)、默认参数、可变参数(可变位置参数,可变关键字参数)、命名关键字参数; 实参(调用函数时):位置参数,关键字参数; 不同类型的参数,定义时顺序很重要(必须按以下...

    目录

    可变参数

    可变位置参数

    可变关键字参数

    混合使用

    强制关键字参数

    默认参数


    Python函数的参数非常灵活:

    • 形参(函数定义时):普通参数(位置参数)、默认参数、可变参数(可变位置参数,可变关键字参数)、命名关键字参数;
    • 实参(调用函数时):位置参数,关键字参数;

    不同类型的参数,定义时顺序很重要(必须按以下顺序给出不同类型参数):

    def func(positional_args, keyword_args, *tuple_grp_args, **dict_kw_args):
        # ...
    

    可变参数

    可变位置参数

    定义参数时前面加一个星号*,表示这个参数是可变的,可以接受任意多个参数,这些参数构成一个元组(只能通过位置参数传递)。

    传递参数时,可迭代对象(元组、列表)可通过在前面加一个星号*,解构成位置参数(依次把元素传递给函数)。

    def calcSum(*numbers):
        sum = 0
        for n in numbers:
            sum += n
        return sum
    
    print(calcSum())
    print(calcSum(1,2,3))
    print(calcSum(*(1,2,3)))
    print(calcSum(*[1,2,3]))
    

    可变关键字参数

    定义参数时前面加两个星号**,表示这个参数为可变关键字参数,可以接受任意多个参数,这些参数构成一个字典,只能通过关键字参数传递。

    传递参数时,字典对象(Key必须为str类型)可通过在前面加两个星号**,解构为关键字参数。

    def add(a,b):
        return a+b
    
    data = {'a':3,'b':4}
    print(add(**data))    #关键字参数解构
    

    混合使用

    当可变位置参数和可变关键字参数一起使用时候,可变位置参数必须在前。

    def fn(x,y,*args,**kwargs):
        print(x) # 1
        print(y) # 2
        print(args) # (3,4,5)
        print(kwargs) # {'a':6, 'b':7}
    
    fn(1,2,3,4,5,a=6,b=7)
    

    强制关键字参数

    关键字参数能够使函数调用意图更加明确;对于容易混淆参数的函数,可以声明只能以关键字形式给出的参数(特殊参数*以后的参数,都是强制关键字参数)。

    # key与value参数只能以关键字参数方式给出
    def keyParam(one, *, key, value='v'):
        print(one, key, value)
    
    if __name__=="__main__":
        keyParam(1, key='one')    
        keyParam(1, key='one', value='one-1')
    

    默认参数

    参数的默认值,会在每个模块加载时(很多模块会在程序启动时加载)求出;模块一旦加载,参数的默认值就固定不变了;而且所有使用默认参数的函数都共享此默认值,若默认值为动态值(如字典、列表等),会产生奇怪的行为(任何一个函数对其的修改,都会影响其他函数)。

    def logMsg(msg:str, when=datetime.datetime.now()):
        print(when, msg)
    
    def logMsg2(msg:str, when=None):
        when = when if when else datetime.datetime.now()
        print(when, msg)
    
    if __name__=="__main__":
        logMsg('one-befor')
        logMsg2('two-befor')
        print('wait one second')
        time.sleep(1)
        logMsg('one-after')
        logMsg2('two-after')
        # one-befor与one-after的时间是相同的,都是模块加载时的时间
    

    注意:若参数默认类型是可变类型,一定用None作为默认值,然后在代码中设定所需的默认值。如下所示,getCode调用会不断累加默认值(作为默认值的列表,会不断的追加内容):

    def getCode(msg:str, code:list=[]):
        code.append(msg)
        print(code)
    
    def getCode2(msg:str, code:list=None):
        if code is None:
            code = []
        code.append(msg)
        print(code
    
    if __name__=="__main__":
        getCode('one')    # ['one']
        getCode2('one')    # ['one']
        getCode('two')    # ['one', 'two']
        getCode2('two')    # ['two']
    
    展开全文
  • 一、默认参数 在C++中,可以为参数指定默认值。在函数调用时没有指定与形参相对应的实参时, 就自动使用默认参数默认参数的语法与使用: ...(#add 这是定义时,类的成员函数参数表在声明时默认参数位于参数
  • http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001374738449338c8a122a7f2e047899fc162f4a7205ea3000########################################################函数参数:...

    参考:

    http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001374738449338c8a122a7f2e047899fc162f4a7205ea3000


    ########################################################


    函数参数:必选参数、默认参数、可选参数、关键字参数


    ########################################################


    默认参数:放在必选参数之后

    计算x平方的函数:

    1. def power(x):
    2. return x*x
    power(5)



    计算x的立方

    1. def power(x):
    2. return x*x*x

    这样的话每次计算不同幂函数都要重写函数,非常麻烦,可使用以下代码计算:

    1. def power(x, n):
    2. s= 1
    3. while n> 0:
    4. n=n -1
    5. s=s*x
    6. return s



    使用修改后的power函数,可以计算任意n次方

    不过每次调用函数必须输入两个参数,使用默认参数可以进一步简化函数:

    1. def power(x, n=2):
    2. s= 1
    3. while n> 0
    4. n=n -1
    5. s=s*x
    6. return s



    设置默认参数时注意事项:必选参数在前,默认参数在后


    默认参数最大好处:降低调用函数的难度

    学生注册,需要传入name和gender:

    1. def enroll(name, gender):
    2. print 'name :',name
    3. print 'gender :',gender

    如果继续传入年龄、城市等信息咋么办,这会使得调用函数的复杂度大大增加:

    把年龄、城市设为默认参数可以简化函数:

    1. def enroll(name, gender, age=6, city='Beijing'):
    2. print 'name :',name
    3. print 'gender :',gender
    4. print 'age :',age
    5. print 'city :',city



    有多个默认参数化时,调用的时候,既可以按顺序提供默认参数,比如调用enroll('zj', 'M', 8);也可以不按顺序提供部分默认参数,如enroll('Ad', 'a', city='dad')

    默认参数也有缺陷的地方:

    1. def add_end(L=[]):
    2. L.append( 'END')
    3. return L



    原因:函数在定义时,默认参数L所制定的地址已经确定,而L是一个list,所以每次调用该函数时,如果改变了L的内容,则下次调用时,默认参数的内容就会改变

    note: 默认参数必须指向不变对象!!!

    如上代码可使用None实现:

    1. def add_end(L=None):
    2. if L is None:
    3. L=[]
    4. L.append( 'END')
    5. return L



    ##################################################################


    可变参数:就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个

    在参数前面加上*就是可变参数。在函数内部,参数numbers接收得到的是一个tuple,调用该函数时,可以传入任意个参数,包括0个参数:

    1. def calc(*numbers):
    2. sum= 0
    3. for n in numbers:
    4. sum= sum+n*n
    5. return sum



    如何调用一个list或者tuple,可以如上所示,在list或tuple前面加上一个*号,把list或tuple的元素变成可变参数传进去


    ####################################################################


    关键字参数

    允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装成一个dict

    使用**表示关键字参数




    函数person不仅可以只传入必选参数,也可以传入任意个数的关键字参数


    也可以类似可变参数,先组装一个dict,然后,把该dict转换为关键字参数传进去:

    1. kw={ 'city': 'Beijing', 'job': 'Engineer'}
    2. person( 'Jack', 24, city=kw[ 'city'], job=kw[ 'job'])
    3. person( 'Jack' , 24, **kw)



    #############################################################


    参数组合

    参数定义的顺序:必选参数、默认参数、可变参数和关键字参数




    #######################################################


    in summary:

    默认参数一定要用不可变对象,如果是可变对象,运行会有逻辑错误!

    *args是可变参数,args接收的是一个tuple;

    **kw是关键字参数,kw接收的是一个dict

    展开全文
  • ​ 在Java中,为函数参数添加默认值是不被允许的,这是为了防止默认参数函数重载同时使用时二义性的问题,考虑下面的例子: void func(p1: String, p2: String, p3: String = default) { // do something } ...
  • 主要介绍了Python函数参数的使用及默认参数的陷阱,文中将函数参数分为必选参数默认参数、可变参数和关键字参数来讲,要的朋友可以参考下
  • 主要介绍了深入浅出ES6新特性之函数默认参数和箭头函数 的相关资料,需要的朋友可以参考下
  • 主要介绍了C++中的默认参数和占位参数及较之C语言的拓展,需要的朋友可以参考下
  • #输出的函数参数个数 print(sum.__code__.co_varnames) # ('a', 'b') #这里会输出函数用到的所有变量名,不只是参数名 print(sum.__defaults__) # None # 返回参数的初始值 #另外还发现了个...
    def sum(a,b):
        return(a+b)
    
    print(sum.__code__.co_argcount)
    # 2
    #输出的函数参数个数
    print(sum.__code__.co_varnames)
    # ('a', 'b')
    #这里会输出函数用到的所有变量名,不只是参数名
    
    print(sum.__defaults__)
    # None
    # 返回参数的初始值
    
    #另外还发现了个东西
    import inspect
    inspect.getargspec(sum)
    # ArgSpec(args=['a', 'b'], varargs=None, keywords=None, defaults=None)
    

     

    展开全文
  • Python函数参数传递-位置参数、关键字参数默认参数、不定长参数 1. 函数参数 参数列表:如果函数所实现的需求中涉及到未知项参与运算(这些未知项需要函数的调用者来决定),就可以将未知项设置为参数。 格式...
  • golang函数实现默认参数

    千次阅读 2019-10-16 23:21:37
    golang函数实现默认参数 golang本身并不支持像C++那样的函数默认参数,不过可以自己实现相关方法达到默认参数的目的; 以下用创建人的个人信息为例,名字必须输入,而邮箱地址和年龄可以不用输入,不输入时使用...
  • Python函数参数多达5种,不像Java那样参数(必选参数)只有一种,而是像C++那样提供默认参数,除此之外,还提供可变参数、关键字参数、命名关键字参数,这样就使得Python函数参数变得十分复杂。但复杂意味着灵活...
  • 除了正常定义的必选参数外,还可以使用默认参数、可变参数和关键字参数, 1 默认参数 定义形式:def calc(para1,para2=None):其中para2是默认参数。 意义:可变参数就是传入的参数个数是可变的。可以是1个、2...
  • python函数除了不带参数,带固定参数之外,还有另外三类函数参数有重要使用价值,是提升python水平需要强化的内容。它们是默认参数、元组参数和字典参数。下面举例子说明。 1.默认参数 即在函数定义时赋值的参数。...
  • Python获取函数参数个数和默认参数

    千次阅读 2020-07-16 11:26:11
    前言:本博文主要讲解Python获取函数参数个数和默认参数。 文章目录一、创建函数二、引出问题三、解决问题 一、创建函数 创建一个函数可以用来计算三个数的和,如下: def addnum3(num1, num2, num3): """ 该函数...
  • 详细介绍Python函数中的默认参数

    千次阅读 2020-03-11 21:59:43
    详细介绍Python函数中的默认参数 import datetime as dt def log_time(message, time=None): if time is None: time=dt.datetime.now() print("{0}: {1}".format(time.isoformat(), message)) 最近我在一段...
  • 通过默认函数参数,你可以初始化带有默认值的正式参数。如果不初始化具有某些值的参数,则该参数的默认值为undefined。 请看下列代码: function foo(num1){ console.log(num1); } foo(); 在调用函数foo时,你没有...
  • C++中允许为函数提供默认参数,又名缺省参数。 使用默认参数时的注意事项: ① 有函数声明(原型)时,默认参数可以放在函数声明或者定义中,但只能放在二者之一。建议放在函数声明中。 double sqrt(double f = 1.0);...
  • // 提交 handleSubmit = async (values, record, ... // 默认参数是values, record两个 新增的是type参数 console.log('????', values, record, type) const { dispatch } = this.props; const params ...
  • 所谓默认参数就是指当函数调用中省略了实参时自动使用的一个值,这个值就是给形参指定的默认值。 默认参数代码展示: 默认参数一般放置在一般参数后面。注意:一旦为某个形参指定了默认值,那么它后面所有形参...
  • python为了简化函数的调用,提供了默认参数机制: 这样在调用pow函数时,就可以省略最后一个参数不写: 在定义有默认参数函数时,需要注意以下: 必选参数必须在前面,默认参数在后; 设置何种参数默认参数?...
  • 使用方法:(1)在函数声明或定义时,直接对参数赋值,该参数就是默认参数。(2)在函数调用时,省略部分或全部参数,这时就会使用默认参数进行代替。 注意事项:(1)一般在声明函数是设置默认参数。 如果在函数...
  • 在声明函数原型时,为一个或者多个形参指定默认值,以后调用这个函数时,若省略某一个实参,c++则自动的以默认值作为相应参数的值。 实列说明: #include<iostream> using namespace std; int add(int x=4,...
  • 构造函数默认参数

    2021-02-17 13:41:00
    在C++中,有些类的函数默认参数的(普通函数默认参数在此不做讲解) Person.h class Person { private: string m; int n; public: Person(string name, int age = 10); } Person.cpp Person::Person...
  • 这两天遇到函数默认参数的bug,在互联网上好好总结了一下: 如非特别说明,下文均基于Python3 一、默认参数 python为了简化函数的调用,提供了默认参数机制: def pow(x, n = 2): r = 1 while n > 0: r *= ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,046,645
精华内容 2,418,658
关键字:

默认参数