精华内容
下载资源
问答
  • python函数的4种参数类型

    万次阅读 多人点赞 2019-06-29 16:18:16
    总结 python 函数中的不同参数类型的使用方法。 在调用函数时,通常会传递参数,函数内部的代码保持不变,针对 不同的参数 处理 不同的数据。 位置传参、关键字传参、默认值参数、多值参数等。 1、参数传递 形参...

    总结 python 函数中的不同参数类型的使用方法。

    在调用函数时,通常会传递参数,函数内部的代码保持不变,针对 不同的参数 处理 不同的数据

    有位置传参、关键字传参、默认值参数、多值参数等。

    1、参数传递

    形参和实参:

    • 形参定义 函数时的 参数变量
    • 实参调用 函数时,使用的参数变量

    参数传递的过程,就是 把实参的引用 传递给 形参 ,使用实参的值来执行函数体的过程。

    Python 中,函数的 实参/返回值 都是是靠 引用 来传递来的

    2、位置实参

    按照参数位置,依次传递参数,这是最普通的方式。

    def location(a, b)
        print(a + b)
    
    location(3, 9)
    "调用函数时,按顺序传递参数,3 传给 a,9 传给 b"
    

    3、关键字实参

    如果不想严格按照顺序传递参数,也可以按关键字传递。

    def location(a, b)
        print(a + b)
    
    location(b = 3, a = 9)
    "调用函数时,按关键字传递参数,3 传给 b,9 传给 a"
    

    4、缺省参数

    定义函数时,可以给 某个参数 赋值一个默认值,具有默认值的参数就叫做 缺省参数

    • 调用函数时,如果没有传入 缺省参数 的值,则在函数内部使用 参数默认值
    • 将常见的值设置为参数的缺省值,从而 简化函数的调用
      • 要使用 最常见的值 作为默认值
      • 如果一个参数的值 不能确定,则不应该设置默认值,具体的数值在调用函数时,由外界传递!

    例如:对列表排序的方法

    gl_num_list = [6, 3, 9]
    
    "默认就是升序排序,因为这种应用需求更多"
    gl_num_list.sort()
    print(gl_num_list)
    
    "只有当需要降序排序时,才需要传递 'reverse' 参数"
    gl_num_list.sort(reverse=True)
    print(gl_num_list)
    

    缺省参数的定义位置:

    • 必须保证带有默认值的缺省参数在参数列表末尾!

    调用带有多个缺省参数的函数:

    • 调用函数时,如果有 多个缺省参数需要指定参数名,这样解释器才能够知道参数的对应关系!
    def print_info(name, title="", gender=True):
        gender_text = "男生"
    
        if not gender:
            gender_text = "女生"
    
        print("%s%s 是 %s" % (title, name, gender_text))
    
    
    # 提示:在指定缺省参数的默认值时,应该使用最常见的值作为默认值!
    print_info("小明")
    print_info("老王", title="班长")
    print_info("小美", gender=False)
    

    5、多值参数

    当函数需要处理的参数个数不确定时,可使用 多值参数

    python 中有两种多值参数:

    • 接收 元组:参数名前加 一个 *
    • 接收 字典:参数名前加 两个 *

    一般在给多值参数命名时,习惯使用以下两个名字

    • *args — 存放 元组 参数
    • **kwargs — 存放 字典 参数,(kwkeywordkwargs键值对参数
    def demo(num, *args, **kwargs):
    
        print(num)
        print(args)
        print(kwargs)
    
    demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
    
    输出:
    1
    (2, 3, 4, 5)
    {'name': '小明', 'age': 18, 'gender': True}
    

    拆包

    在上面多值参数传递时,实际上使用了拆包功能。

    拆包主要用于元组和字典参数的传递。

    在调用带有多值参数的函数时,使用拆包简化参数的传递:

    • 直接将一个 元组变量 实参传递给元组形参 args
      • 元组变量前,加 *
    • 直接将一个 字典变量 实参传递给字典形参 kwargs
      • 字典变量前,加 **
    def demo(*args, **kwargs):
    
        print(args)
        print(kwargs)
    
    gl_nums = (1, 2, 3)
    gl_xiaoming = {"name": "小明", "age": 18}
    
    "变量名前必须要加 * 号,否则不能无法正常拆包"
    
    "错误演示(不加 * 号):"
    demo(gl_nums, gl_xiaoming)
    输出:
    ((1, 2, 3), {'name': '小明', 'age': 18})
    {}
    
    "正确演示(加 * 号):"
    demo(*gl_nums, **gl_xiaoming)
    输出:
    (1, 2, 3)
    {'name': '小明', 'age': 18}
    
    展开全文
  • 假设要利用模板元编程获取位于index的参数的类型: template&... // FuntionType的返回值类型和参数类型? }; int f(int, short, float); static_assert(is_same_v<decltype(f), int(int...

    假设要利用模板元编程获取位于index的参数的类型:

    template<int index, class FuntionType>
    struct ArgTypeAt
    {
        // FuntionType的返回值类型和参数类型?
    };
    
    int f(int, short, float);
    static_assert(is_same_v<decltype(f), int(int, short, float)>);
    using Arg2Type = ArgTypeAt<2, decltype(f)>::type; // 假设这样使用模板

    这时FunctionType就是一个单独的类型int(int, short, float)了,里面含有各参数的类型。要把FuntionType分离成返回值类型和参数类型,方法是利用模板特化,然后参数类型是一个包,再把参数包展开就能得到各位置参数的类型:

    template<int index, class FuntionType>
    struct ArgTypeAt;
    
    template<class ResultType, class FirstArgType, class... ArgsType>
    struct ArgTypeAt<0, ResultType(FirstArgType, ArgsType...)>
    {
        using type = FirstArgType;
    };
    
    template<int index, class ResultType, class FirstArgType, class... ArgsType>
    struct ArgTypeAt<index, ResultType(FirstArgType, ArgsType...)>
    {
        using type = typename ArgTypeAt<index - 1, ResultType(ArgsType...)>::type;
    };
    
    int f(int, short, float);
    static_assert(is_same_v<ArgTypeAt<2, decltype(f)>::type, float>); // OK

    匹配过程是:ArgTypeAt<2, int(int, short, float)>::type = ArgTypeAt<1, int(short, float)>::type = ArgTypeAt<0, int(float)>::type = float

    还有个问题,如果把f的调用约定(默认是__cdecl)改成__stdcall这个模板特化就不匹配了,因为修饰符也是类型的一部分,而C++的泛型并没有修饰符变了还能匹配的方法(只有类型变了能匹配)。参考标准库的std::function定义了一堆宏,我也用宏改造成下面这样:

    template<int index, class FuntionType>
    struct ArgTypeAt;
    
    #define DEF_ARG_TYPE_AT(CV) \
        template<class ResultType, class FirstArgType, class... ArgsType>                   \
        struct ArgTypeAt<0, ResultType CV(FirstArgType, ArgsType...)>                       \
        {                                                                                   \
            using type = FirstArgType;                                                      \
        };                                                                                  \
                                                                                            \
        template<int index, class ResultType, class FirstArgType, class... ArgsType>        \
        struct ArgTypeAt<index, ResultType CV(FirstArgType, ArgsType...)>                   \
        {                                                                                   \
            using type = typename ArgTypeAt<index - 1, ResultType CV(ArgsType...)>::type;   \
        };
    
    DEF_ARG_TYPE_AT(__cdecl)
    #ifdef _M_CEE
    DEF_ARG_TYPE_AT(__clrcall)
    #endif
    #if defined(_M_IX86) && !defined(_M_CEE)
    DEF_ARG_TYPE_AT(__fastcall)
    #endif
    #ifdef _M_IX86
    DEF_ARG_TYPE_AT(__stdcall)
    #endif
    #if ((defined(_M_IX86) && _M_IX86_FP >= 2) \
        || defined(_M_X64)) && !defined(_M_CEE)
    DEF_ARG_TYPE_AT(__vectorcall)
    #endif
    
    // OK
    static_assert(is_same_v<ArgTypeAt<2, int(int, short, float)>::type, float>);
    static_assert(is_same_v<ArgTypeAt<2, int __cdecl(int, short, float)>::type, float>);
    static_assert(is_same_v<ArgTypeAt<2, int __fastcall(int, short, float)>::type, float>);
    static_assert(is_same_v<ArgTypeAt<2, int __stdcall(int, short, float)>::type, float>);
    static_assert(is_same_v<ArgTypeAt<2, int __vectorcall(int, short, float)>::type, float>);

    还有其他修饰符constvolatilenoexcept、引用、成员函数同理,这里就不写了

    展开全文
  • Python函数参数类型

    万次阅读 2017-01-07 21:44:34
    函数参数 定义函数参数): 普通参数,默认参数,可变参数(可变位置参数,可变关键字参数),keyword-only 参数 调用函数(传参): 位置参数,关键字参数参数结构(位置参数解构,关键字参数解构) 普通...

    函数的参数

    定义函数(参数):

    普通参数,默认参数,可变参数(可变位置参数,可变关键字参数),keyword-only 参数

    调用函数(传参):

    位置参数,关键字参数,参数结构(位置参数解构,关键字参数解构)


    普通参数 x,y:

    def add(x,y)

      return x + y


    默认参数  x=1:

    def inc(base,x =1):

    return base +x

    inc(3)

    4

    inc(3,2)

    5

    参数可以有默认值, 但当一个参数有默认值时,调用时如果不传递此参数,会使用默认值

    带默认值参数必须在不带默认值参数之后,否则会报错SyntaxError

    def  inc(x=0,y):

    return x+y

     File "<ipython-input-19-d6c7b4f89658>", line 1
        def inc(x= 0,y):
               ^
    SyntaxError: non-default argument follows default argument
     
    
     
    可变位置参数: 
    

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


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


    参数的混合使用:

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

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

    #普通参数可以和可变参数一起使用,但是传参的时候必须匹配

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

    #关键字可变参数不允许在普通参数之前

    def  fn(**kwargs,x):

    print(x)

    #上面的方式定义会出错


    #默认参数可以在可变位置参数之前

    def fn(x=5,*args):

    print(x)

    pprint(args)


    #位置可变参数可以在普通参数之前,但是在位置可变参数之后的普通参数变成可keyword-only 参数


    keyword-only参数:

    Python3特性

    #在*号之后的参数只能通过关键字参数传递的叫keyword-only参数

    可变位置参数之后的参数也是keyword-only参数


    def  fn(*,x):

    print(x)

    fn(1,x=3)                   #此时x 只能通过关键字参数传递,如果安装普通参数传递,会被*和可变位置参数吃掉

    fn(x=3)


    def fn(*args,x):

    print(args)

    print(x)

    #keyword-only 参数可以有默认值

    keyword-only 参数可以和默认参数一起出现,不管它有没有默认值,不管默认参数是不是keyword-only


    参数解构:

    可以把一个可迭代对象解构成位置参数

    参数解构发生在函数调用用,可变参数发生在函数定义的时候


    解构的两种形式:

    一个星号*,解构的对象:可迭代对象,解构后的结果,位置参数

    两个星号**,解构的对象:字典,解构的结果,关键字参数

    关键字参数解构,key必须是str类型

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








    展开全文
  • js函数参数传递类型

    千次阅读 2018-07-20 00:10:02
    参考不同人归纳和代码实例,做些学习小结  javascript 数据类型可以分为两类: 基本类型值 primitive type : 比如Undefined,Null,Boolean,Number,String ...基本类型数据作为参数传递时传递值,比...

    参考不同人归纳和代码实例,做些学习小结

     javascript 数据类型可以分为两类:

    • 基本类型值 primitive type :      比如Undefined,Null,Boolean,Number,String
    • 引用类型值,也就是对象类型 : Object type,比如Object,Array,Function,Date

     

    一变量复制时

    基本类型数据作为参数传递时传递值,比如:

    var num1 = 10;//num1赋值为10
    var num2 = num1;//num1的值赋值给num2;
    console.log(num2);//10  ,num2=10;
    num2 += 1;//num2的值+1;
    console.log(num1); //10  打印出num1=10,说明num1不被num2的值影响
    console.log(num2); //11  num2=11了;

    然而对象类型被复制时

    var obj1 = {
      name : "111"
    };
    var obj2 = obj1;
    console.log(obj2.name); //111
    obj2.name = "222";
    console.log(obj1.name); //222

    obj1赋值给obj2,obj2对象指向新对象时,obj2.name=222,obj1也改变,obj1.name=222。

    理由:对象被复制时并不会在堆内存中新生成一个一模一样的对象,只是多了一个保存指向这个对象指针的变量。obj1的值复制给obj2,而这个值的副本实际上是一个指针,这个指针指向存储在堆中的一个对象,也就是说创建了一个新的内存地址传给了obj2,obj1和obj2两个变量同时指向了同一个Object,当去改变这个对象时,他们的值都会改变,也就是说他们中任何一个作出的改变都会反映在另一个身上。

     

    二函数传递参数时

    《js高级程序设计》上是这样叙述参数传递的:所有函数的参数都是按值传递的,

    也就是说把函数外部的值复制给函数内部的参数

    基本数据类型:

    var count = 10;
    function num(num1){
       num1 = 1;
       return num1;
    }
    var result = num(count);
    console.log(result);//1

    console.log(count);//10,count虽然被做实参调用了,但输出的值是10,说明count被复制了一个副本值传给了函数,但自身的值未改变

     

    对象传参实例

    var person  = {
        name : "Tom"
    };
    function obj(peo){
        peo.name = "Jerry";
        return peo;
    }
    var result = obj(person);
    console.log(result.name);// Jerry
    console.log(person.name);// Jerry

    在上面的例子中,把person复制传入obj()中,peo和person指向了同一个对象,而在peo中修改了name属性,其实修改了它们共同指向的对象的name属性,相对应的外部person所引用的name属性也就改变了,所以打印出来的为Jerry。其实这个乍一看,感觉引用类型的参数是按照引用传递的,这就是我最初犯得错误。再来看一个例子。

    var person = {
        name : "Tom"
    }; 
    function obj(peo){
        peo = {
           name : "Jerry"
        };
        return peo;
    }
    var result = obj(person);
    console.log(result.name);// Jerry

    console.log(person.name);// Tom

            上面的例子中,在函数中重新定义了一个对象,也就是现在堆内存中有两个对象,外部的person指向的是老的对象,被传入参数后指向的是新定义的对象,所以调用后返回的值是新定义的对象的值。如果是参数是按引用传递的,那么person.name打印出来的结果为Jerry,从这点可以得出参数是按值传递的(有的地方叫做按共享传递)。

    通过别人的思路来学习,不妥之处请见谅。

    参考:https://www.cnblogs.com/open-wang/p/5208606.html

     

     

     

     

     

     

     

    展开全文
  • c++11模板:获取函数参数类型

    千次阅读 2019-02-23 12:55:18
    假设我们已经知道一个函数类型的定义double(unsigned char*, unsigned char*),如何获取这个函数定义中的输入和输出参数类型呢? c++11提供的模板函数std::function和std::tuple_element可以将一个函数定义的输入和...
  • python-函数参数类型检查

    千次阅读 2019-04-24 15:08:56
    python在3.5后引入了参数类型注解,例: def add(x:int,y:int)->int:#对x,y和返回值都进行注释,为int类型 return x + y 注:注解是对函数参数和返回值的‘注释’,没有强制定义的作用(因为python是动态语言啊...
  • TS基础之(二)函数声明及参数类型

    千次阅读 2020-08-31 18:01:35
    函数声明的参数 void类型 void即返回值;void表示没有返回值 function run():void{ console.log(123) }; function main():number{ return 123; } 参数传递方式 默认参数、可选参数 function run(str:...
  • C++中函数参数类型为指针的指针

    万次阅读 2018-08-08 08:48:02
    1 参数类型是非指针情况 例如,如下函数 void func(char a) { a = 'a'; return; } 使用如下方式调用func()函数 char b = 'b'; func(b); 此时,变量a是func()函数的形参,变量b是func()函数的实参...
  • 1,传递基本类型参数,请看下面例子 function addNum(num) { num + = 10; return num; } var count = 20; var result = addTen(count); alert(count); //20, not change alert(result); //30 在调用函数...
  • C语言函数参数引用类型回顾

    千次阅读 2019-07-26 17:12:21
    涉及:数组参数、指针参数... *函数参数是指针和指针引用的区别在于: 参数是指针:参数可以看作传的是地址,不能改变实参所指向的地址。 参数是指针引用:参数可以看作是实参指针本身,可以改变内部所指向的地址...
  • python里常用的几种函数类型

    万次阅读 2018-03-21 14:00:43
    那么函数有哪些类型呢,来看一下: 无参数,无返回值无参数返回值有参数,无返回值有参数返回值 对,这么四种,第一种是不需要传入参数,也不需要返回值得,调用这类函数时直接就输出了结果。...
  • 当你写的函数方法,要被其他人调用时, 你想让他知道传入参数的数据类型, 可以这样定义 def demo(name: str, age: int): print(name, type(name)) print(age, type(age)) demo(1, 2) # 这里的参数1会显示黄色, 但是...
  • TS函数类型

    万次阅读 多人点赞 2019-07-11 09:58:27
    一个函数有输入和输出,要在 TypeScript 中对其进行约束,需要把输入和输出都考虑到,其中函数声明的类型定义较简单 function sum(x: number, y: number): number { return x + y; } 在调用时,输入多余的(或者...
  • python作为一门动态语言,在使用变量之前是不需要进行定义,...时候我们定义函数时也想限定参数类型,本片博文主要就是为了解决定义函数时,如何限定参数的类型。 其实在python中限定函数的类型是很简单的,例...
  • 函数类型和参数类型

    千次阅读 2016-05-23 13:01:56
    //1、参数(所有实例默认在函数返回值为int类型,即返回类型为一个值) //(1)、传值参数:实参要复制一份传值给形参(形参的改变对实参没有影响),复制过程是由形参类型的复制构造函数来完成。函数运行结束时,...
  • python定义函数时默认参数注意事项

    千次阅读 2020-12-14 07:11:38
    如果在调用一个函数时,没有传递默认参数,则函数内的默认参数是对函数的默认参数属性__defaults__的引用,如def func(arg1=[]): arg1.append(2)调用func时如果没有传参,上面的arg1就是func.__defaults__[0]的引用没...
  • 用结构体类型的数据作函数参数

    万次阅读 多人点赞 2018-04-05 20:42:50
    用结构体变量作函数参数:运行结果:用结构体变量作实参时,采取的也是“值传递”方式,将 结构体变量所占的内存单元的内容(结构体变量成员列表) 全部顺序传递给形参,这里形参也得是结构体变量。但是,这种传递...
  • python对函数参数和返回值进行指定类型和检查

    万次阅读 多人点赞 2019-07-16 22:34:21
    python一直以来都不是开发大工程的主流语言,不管是前端还是后端,主要的原因其实就是以下几点: ...但是,在python3.5之后,就新增了对函数参数和返回值的类型指定和检查,以及在新建变量时也可以指定类型。 基...
  • C++ 的main函数参数 数据类型转换
  • C语言函数参数

    千次阅读 2019-03-21 23:07:27
    一、函数参数可以是变量、变量指针和变量引用: void funcA(int8_t x) { x=x+1; } 代码说明:该函数参数属于值传递,在调用该函数时,仅仅只是把实参的值拷贝了一份赋值给了形参x,之后的任何操作都不会影响到...
  • JavaScript函数中的参数类型

    万次阅读 2016-06-05 10:03:58
    }由于,javascript不需要声明参数类型,所以调用函数时,传入的参数p完全可以是整型变量或者是布尔型变量,这些类型的数据都没有setAge()方法,但程序强制调用该方法,肯定会导致程序出现错误,
  • idea等去掉函数参数类型显示

    千次阅读 2018-01-15 11:07:10
    如下图,IDEA(phpstorm)默认设置显示函数参数类型,参数较多时候编辑比较蛮烦。 可以如下位置修改:
  • golang 传入函数作为参数类型

    千次阅读 2018-12-21 08:57:58
    package main import "fmt" #############################################################################################...可以这样定义函数格式的类型,即相同输入输出值的函数都为此类型   ...
  • C语言使用枚举类型作为函数参数

    万次阅读 2019-08-14 17:31:17
  • 可以通过该指针变量调用函数函数指针两个用途:调用函数、做函数参数: 调用函数,如下所示:   输出结果如下: 由以上可以说明成功调用。    b.无参函数指针做参数的...
  • C++传入任意的函数类型作为参数

    千次阅读 2018-12-16 22:54:28
    C++编程中,有些时候需要传入函数作为参数,这在STL中作为谓词经常用到。传入的可以是函数函数对象和lambda表达式。编程的时候,把它当成一个模板类型传入即可。以下给出一个简单的例子: #include &amp;lt;...
  • 2018年3月23日11:43:06 using System.Reflection //取得YourClassName中的名称为foo的方法 Type className = Type(YourClassName) .../*取得方法的参数个数、参数类型和名称、返回值类型*/ ...
  • 这主要是由于string内部保存值方式的原因 string是通过一个final char[]数组进行保存的 由于final类型的数组值不能够改变,所以在外部调用函数时将string地址的引用进行传递给函数参数函数内部再修改这个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,400,158
精华内容 960,063
关键字:

常用的函数参数类型有