精华内容
下载资源
问答
  • 跟老齐学Python之总结参数传递
    千次阅读
    2020-12-09 13:21:26

    就前面所讲,函数的基本内容已经完毕。但是,函数还有很多值得不断玩味的细节。这里进行阐述。

    参数的传递

    python中函数的参数通过赋值的方式来传递引用对象。下面总结通过总结常见的函数参数定义方式,来理解参数传递的流程。

    def foo(p1,p2,p3,...)

    这种方式最常见了,列出有限个数的参数,并且彼此之间用逗号隔开。在调用函数的时候,按照顺序以此对参数进行赋值,特备注意的是,参数的名字不重要,重要的是位置。而且,必须数量一致,一一对应。第一个对象(可能是数值、字符串等等)对应第一个参数,第二个对应第二个参数,如此对应,不得偏左也不得偏右。

    >>> def foo(p1,p2,p3):

    ...     print "p1==>",p1

    ...     print "p2==>",p2

    ...     print "p3==>",p3

    ...

    >>> foo("python",1,["qiwsir","github","io"])    #一一对应地赋值

    p1==> python

    p2==> 1

    p3==> ['qiwsir', 'github', 'io']

    >>> foo("python")

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: foo() takes exactly 3 arguments (1 given)    #注意看报错信息

    >>> foo("python",1,2,3)

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: foo() takes exactly 3 arguments (4 given)    #要求3个参数,实际上放置了4个,报错

    def foo(p1=value1,p2=value2,...)

    这种方式比前面一种更明确某个参数的赋值,貌似这样就不乱子了,很明确呀。颇有一个萝卜对着一个坑的意味。

    还是上面那个函数,用下面的方式赋值,就不用担心顺序问题了。

    >>> foo(p3=3,p1=10,p2=222)

    p1==> 10

    p2==> 222

    p3==> 3

    也可以采用下面的方式定义参数,给某些参数有默认的值

    >>> def foo(p1,p2=22,p3=33):    #设置了两个参数p2,p3的默认值

    ...     print "p1==>",p1

    ...     print "p2==>",p2

    ...     print "p3==>",p3

    ...

    >>> foo(11)     #p1=11,其它的参数为默认赋值

    p1==> 11

    p2==> 22

    p3==> 33

    >>> foo(11,222)     #按照顺序,p2=222,p3依旧维持原默认值

    p1==> 11

    p2==> 222

    p3==> 33

    >>> foo(11,222,333)  #按顺序赋值

    p1==> 11

    p2==> 222

    p3==> 333

    >>> foo(11,p2=122)

    p1==> 11

    p2==> 122

    p3==> 33

    >>> foo(p2=122)     #p1没有默认值,必须要赋值的,否则报错

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: foo() takes at least 1 argument (1 given)

    def foo(*args)

    这种方式适合于不确定参数个数的时候,在参数args前面加一个*,注意,仅一个哟。

    >>> def foo(*args):         #接收不确定个数的数据对象

    ...     print args

    ...

    >>> foo("qiwsir.github.io") #以tuple形式接收到,哪怕是一个

    ('qiwsir.github.io',)

    >>> foo("qiwsir.github.io","python")

    ('qiwsir.github.io', 'python')

    上一讲中已经有例子说明,可以和前面的混合使用。此处不赘述。

    def foo(**args)

    这种方式跟上面的区别在于,必须接收类似arg=val形式的。

    >>> def foo(**args):    #这种方式接收,以dictionary的形式接收数据对象

    ...     print args

    ...

    >>> foo(1,2,3)          #这样就报错了

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: foo() takes exactly 0 arguments (3 given)

    >>> foo(a=1,b=2,c=3)    #这样就可以了,因为有了键值对

    {'a': 1, 'c': 3, 'b': 2}

    下面来一个综合的,看看以上四种参数传递方法的执行顺序

    >>> def foo(x,y=2,*targs,**dargs):

    ...     print "x==>",x

    ...     print "y==>",y

    ...     print "targs_tuple==>",targs

    ...     print "dargs_dict==>",dargs

    ...

    >>> foo("1x")

    x==> 1x

    y==> 2

    targs_tuple==> ()

    dargs_dict==> {}

    >>> foo("1x","2y")

    x==> 1x

    y==> 2y

    targs_tuple==> ()

    dargs_dict==> {}

    >>> foo("1x","2y","3t1","3t2")

    x==> 1x

    y==> 2y

    targs_tuple==> ('3t1', '3t2')

    dargs_dict==> {}

    >>> foo("1x","2y","3t1","3t2",d1="4d1",d2="4d2")

    x==> 1x

    y==> 2y

    targs_tuple==> ('3t1', '3t2')

    dargs_dict==> {'d2': '4d2', 'd1': '4d1'}

    通过上面的例子,看官是否看出什么名堂了呢?

    更多相关内容
  • 名称传递参数

    2017-02-28 23:54:00
    参数的值在它被传递给函数之前被确定。但是,如果我们需要编写一个接收参数不希望马上计算,直到调用函数内的表达式才进行真正的计算的函数。对于这种情况,Scala提供按名称参数调用函数。 示例代码如下: ...

    通常情况下,函数的参数是传值参数;即参数的值在它被传递给函数之前被确定。但是,如果我们需要编写一个接收参数不希望马上计算,直到调用函数内的表达式才进行真正的计算的函数。对于这种情况,Scala提供按名称参数调用函数。

    示例代码如下:


     

    结果:


     

    在代码中,如果定义函数的时候,传入参数不是传入的值,而是传入的参数名称(如代码中使用t: => Long而不是t: Long),在调用该函数时,不会立即执行和参数有关的计算,而是到参数真正使用到的时候才进行计算。

     

    结果说明:主函数调用delayed函数后,并不立即执行参数(time()函数的结果),而是跳过,直接执行delayed函数的第一行,到第二行真正使用到t时,才执行time()函数获取t的值,故有上述结果。

     

    如果将t: => Long改成t: Long,则按照值传递进行计算,结果如下:


    此时主函数调用了delayed函数后就直接先执行time()函数获取t的值

     

    另一个示例代码如下:


    这里调用了一个log函数,传入的参数中有1/0,按理说应该会报异常,但实际结果却是代码顺利的执行完成。为什么呢?这是因为我们在定义log函数的时候使用了“按名称传递参数”,只有到实际执行参数相关的计算时才会检查是否有异常。而代码中if(logEnable) println(msg)这一行代码实际根本就不会执行,自然也就不会存在检查异常的问题了

     

    如果将msg: =>String改为msg: String,则执行代码就会报错


    因为在执行到log(MSG +1 / 0)这一句时就直接计算了1/0,自然就会报错了

     

    使用“按名称传递参数”方式的优点是:1.减少不必要的计算; 2.减少异常

    转载于:https://www.cnblogs.com/yejibigdata/p/6481713.html

    展开全文
  • mybatis 传递参数的7种方法

    万次阅读 多人点赞 2019-07-06 10:23:59
    mybatis 传递参数的7种方法 在实际开发过程中,增删改查操作都要涉及到请求参数的传递,今天这节就集中讲下在mybatis中传递参数的7中方法 单个参数的传递很简单没有什么好将的,这里主要说下多个参数的传递 1.第一种...

    在实际开发过程中,增删改查操作都要涉及到请求参数的传递,今天这节就集中讲下在mybatis中传递参数的7中方法

    单个参数的传递很简单没有什么好将的,这里主要说下多个参数的传递

    项目地址

    1.第一种方式 匿名参数 顺序传递参数

    controller

    @ApiOperation(value = "多个参数查询_匿名顺序传参")
    @GetMapping("findByParams")
    public ResultMsg findByParams(Short gender,String age)
    {
        List result= employeeMapper.selectByGenderAndAge(gender,age);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    List<Employee> selectByGenderAndAge(Short gender,String age );
    

    xml

    <select id="selectByGenderAndAge" resultMap="BaseResultMap" >
      select * from employee where gender = #{gender} and age = #{age}
    </select>
    

    注意这里按参数名去引用的话会报如下错误,mybatis错误提示很细致,这里明确给我们提示,匿名参数只能使用

    arg1, arg0, param1, param2 类似的形式

    这种传参方式的缺点是不够灵活,必须严格按照参数顺序来引用

    BindingException: Parameter 'gender' not found. Available parameters are [arg1, arg0, param1, param2]
    

    所以正确的引用方式如下:

      <select id="selectByGenderAndAge" resultMap="BaseResultMap" >
        select *  from employee where gender = #{param1} and age = #{param2}
      </select>
    

    2.第二种方式 使用@Param注解

    controller

    @ApiOperation(value = "多个参数查询_注解方式传参")
    @GetMapping("findByParams2")
    public ResultMsg findByParams2(Short gender,String age)
    {
        List result= employeeMapper.selectByGenderAndAge2(gender,age);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    使用@Param注解显示的告诉mybatis参数的名字,这样在xml中就可以按照参数名去引用了

    List<Employee> selectByGenderAndAge( @Param("gender") Short gender,@Param("age") String age );
    

    xml

    <select id="selectByGenderAndAge" resultMap="BaseResultMap" >
      select * from employee where gender = #{gender} and age = #{age}
    </select>
    

    3.使用Map传递参数

    实际开发中使用map来传递多个参数是一种推荐的方式

    controller

    @ApiOperation(value = "多个参数查询")
    @GetMapping("findByMapParams")
    public ResultMsg findByMapParams(Short gender,String age)
    {
        Map params = new HashMap<>();
        params.put("gender",gender);
        params.put("age",age);
        List result= employeeMapper.selectByMapParams(params);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    List<Employee> selectByMapParams(Map params);
    

    可以看到使用map来传递多个参数,可以直接使用参数名称进行引用

    <select id="selectByMapParams" resultMap="BaseResultMap" parameterType="map">
      select * from employee where gender = #{gender} and age = #{age}
    </select>
    

    4.用过java bean传递多个参数

    也可以使用bean的方式来传递多个参数,使用时parameterType指定为对应的bean类型即可

    这就传参方式的优点是比较方便,controller层使用@RequestBody接收到实体类参数后,直接传递给mapper层调用即可,不需要在进行参数的转换

    controller

    @ApiOperation(value = "多个参数查询_通过Java Bean传递多个参数")
    @PostMapping("findByBeans")
    public ResultMsg findByBeans(@RequestBody Employee employee)
    {
        List result= employeeMapper.selectByBeans(employee);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    List <Employee> selectByBeans(Employee employee);
    

    xml

    参数的引用直接使用bean的字段

    <select id="selectByBeans" resultMap="BaseResultMap" parameterType="com.wg.demo.po.Employee">
      select
      *
      from employee where gender = #{gender} and age = #{age}
    </select>
    

    测试一下:

    5.直接使用JSON传递参数

    这也是推荐的一种传参方式,controller层收到JSON型数据后,直接传递给mapper层进行查询操作,简单 方便

    controller

    @ApiOperation(value = "多个参数查询_通过JSON传递多个参数")
    @PostMapping("findByJSONObject")
    public ResultMsg findByJSONObject(@RequestBody JSONObject params)
    {
        List result= employeeMapper.findByJSONObject(params);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    List <Employee> findByJSONObject(JSONObject params);
    
    <select id="findByJSONObject" resultMap="BaseResultMap" parameterType="com.alibaba.fastjson.JSONObject">
      select
      *
      from employee where gender = #{gender} and age = #{age}
    </select>
    

    测试一下:

    6.传递集合类型参数List、Set、Array

    在一些复杂的查询中(如 sql中的 in操作),传统的参数传递已无法满足需求,这时候就要用到List、Set、Array类型的参数传递,具体使用如下:

    controller

    @ApiOperation(value = "多个参数查询_通过List、Set、Array传递多个参数")
    @PostMapping("findByList")
    public ResultMsg findByList(@RequestBody List<String> list)
    {
        List result= employeeMapper.findByList (list);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    List <Employee> findByList(List list);
    

    xml

      <select id="findByList" resultMap="BaseResultMap" >
    SELECT * from employee where age in
        <foreach collection="list" open="(" separator="," close=")" item="age">
          #{age}
        </foreach>
      </select>
    

    这里foreach表示循环操作,具体的参数含义如下:

    foreach元素的属性主要有 item,index,collection,open,separator,close。
    item表示集合中每一个元素进行迭代时的别名,
    index指定一个名字,用于表示在迭代过程中,每次迭代到的位置,
    open表示该语句以什么开始,
    separator表示在每次进行迭代之间以什么符号作为分隔符,

    close表示以什么结束

    在使用foreach的时候最关键的也是最容易出错的就是collection属性,该属性是必须指定的,但是在不同情况下,该属性的值是不一样的,主要有一下3种情况:

    • 1.如果传入的是单参数且参数类型是一个List的时候,collection属性值为list
    • 2.如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array
    • 3.如果传入的参数是多个的时候,我们就需要把它们封装成一个Map或者Object

    测试:

    ])

    7.参数类型为对象+集合

    该类参数与java Bean参数形式类似,只不过更复杂一些,如下面的Department类,除了基本字段还包括一个Employee的列表

    bean

    @Data
    public class Department {
        private Long id;
    
        private String deptName;
    
        private String descr;
    
        private Date createTime;
    
        List<Employee> employees;
    
    }
    

    controller

    @ApiOperation(value = "多个参数查询_对象+集合参数")
    @PostMapping("findByDepartment")
    public ResultMsg findByDepartment(@RequestBody Department department)
    {
        List result= employeeMapper.findByDepartment(department);
        return ResultMsg.getMsg(result);
    }
    

    mapper

    List <Employee> findByDepartment(@Param("department")Department department);
    

    xml

    <select id="findByDepartment" resultMap="BaseResultMap" parameterType="com.wg.demo.po.Department">
        SELECT * from employee where dept_id =#{department.id} and age in
        <foreach collection="department.employees" open="(" separator="," close=")" item="employee">
            #{employee.age}
        </foreach>
    </select>
    

    这里foreach 对应Departmen部门中的List employees

    请求参数: 查询部门Id=1,并且年龄 等于24和25的员工

    {
      "createTime": "2019-07-02T10:17:16.756Z",
      "deptName": "string",
      "descr": "string",
      "employees": [
        {
          "age": "24",
        },
        {
          "age": "25",
        }
      ],
      "id": 1
    }
    

    结果:

    {
      "data": [
        {
          "address": "北新街ndcpc",
          "age": "24",
          "createTime": 1562062434000,
          "deptId": "1",
          "gender": 1,
          "id": "318397755696631808",
          "name": "kls0bx19cy"
        },
        {
          "address": "北新街lavi0",
          "age": "25",
          "createTime": 1562062436000,
          "deptId": "1",
          "gender": 1,
          "id": "318397755801489408",
          "name": "gj9q3ygikh"
        }
      ],
      "result": "SUCCESS",
      "resultCode": 200,
      "resultMsg": ""
    }
    
    展开全文
  • 参数的值在它被传递给函数之前被确定。但是,如果我们需要编写一个接收参数不希望马上计算,直到调用函数内的表达式才进行真正的计算的函数。对于这种情况,Scala提供按名称参数调用函数。 示例代码如下:   ...

    通常情况下,函数的参数是传值参数;即参数的值在它被传递给函数之前被确定。但是,如果我们需要编写一个接收参数不希望马上计算,直到调用函数内的表达式才进行真正的计算的函数。对于这种情况,Scala提供按名称参数调用函数。

    示例代码如下:


     

    结果:


     

    在代码中,如果定义函数的时候,传入参数不是传入的值,而是传入的参数名称(如代码中使用t: => Long而不是t: Long),在调用该函数时,不会立即执行和参数有关的计算,而是到参数真正使用到的时候才进行计算。

     

    结果说明:主函数调用delayed函数后,并不立即执行参数(time()函数的结果),而是跳过,直接执行delayed函数的第一行,到第二行真正使用到t时,才执行time()函数获取t的值,故有上述结果。

     

    如果将t: => Long改成t: Long,则按照值传递进行计算,结果如下:


    此时主函数调用了delayed函数后就直接先执行time()函数获取t的值

     

    另一个示例代码如下:


    这里调用了一个log函数,传入的参数中有1/0,按理说应该会报异常,但实际结果却是代码顺利的执行完成。为什么呢?这是因为我们在定义log函数的时候使用了“按名称传递参数”,只有到实际执行参数相关的计算时才会检查是否有异常。而代码中if(logEnable) println(msg)这一行代码实际根本就不会执行,自然也就不会存在检查异常的问题了

     

    如果将msg: =>String改为msg: String,则执行代码就会报错


    因为在执行到log(MSG +1 / 0)这一句时就直接计算了1/0,自然就会报错了

     

    使用“按名称传递参数”方式的优点是:1.减少不必要的计算; 2.减少异常

    展开全文
  • 页面之间传递参数得几种方法

    千次阅读 2019-01-08 02:20:09
    使用QuerySting在页面间传递值已经是一种很老的机制了,这种方法的主要优点是实现起来非常简单,然而它的缺点是传递的值是会显示在浏览器的地址栏上的(不安全),同时又不能传递对象,但是在传递的值少而安全性要求...
  • 前后端接口约定 如何传递参数
  • Shell脚本中参数传递方法常用有8种

    万次阅读 2016-01-23 18:29:32
    Shell脚本中参数传递方法常用有8种 1. $# 传递到脚本的参数个数 2. $* 以一个单字符串显示所有向脚本传递参数变量。与位置变量不同,此选项参数可超过9个 3. $$ 脚本运行的当前进程ID号 4. $! 后台...
  • 传递参数- $ 在执行 Shell 脚本时,向脚本传递参数,脚本内获取参数的格式为:$n。n 代表一个数字,1 为执行脚本的第一个参数,2 为执行脚本的第二个参数,$0为shell脚本名称。其中不受执行方式的影响,即,/bin/sh...
  • 本文只浅显地介绍了三种函数参数传递的方式及其优劣,主要目的是为了介绍引用。在另一篇博文中将会用本文中的主要代码反汇编为汇编代码,从编译器处理函数调用的层面更深入地探讨三种函数参数传递的区别。 C++函数...
  • python打包含有参数传递的exe程序

    千次阅读 2020-08-20 16:50:54
    参数传递 常见的就是 sys.argv还有argparse(这个库不是内置的,需要pip install argparse),前者功能比较简单,能提供的有限,后者虽然不是内置的,需要安装,但是确实功能比较强大。 所以在开发时选择后者(如果...
  • 【单选题】带有默认值的参数一定位于参数列表的末尾。( )【单选题】Python源代码被解释器转换后的格式为( )。【单选题】Python可以开发Web程序,也可以管理操作系统。( ) x = 'abc' y = x y = 100 print(x)【单选题】...
  • mui的页面间传递参数的案例
  • 最近做一个项目,需要在短期之内开发出一个系统来控制一群网站,也就是站群管理系统,还是用PHP开发,然而时间太...优缺点也很明显,优点是便捷快速易懂 缺点是功能限制,只能控制固定的参数或者标签,无法实现网...
  • #1楼 参考:https://stackoom.com/question/gvdl/将const-std-string-作为参数传递的日子已经过去了吗 #2楼 std::string is not Plain Old Data(POD) , and its raw size is not the most relevant thing ever....
  • C#页面间的参数传递

    千次阅读 2012-08-10 16:54:32
    ASP.NET中实现页面间的参数传递 QueryString\Application\Session\Cookie 一.使用QueryString   使用QueryString在页面间传递值是一种非常常见的方法,我们在ASP中就常常用到。  (1)优点和缺点  优点: ...
  • 参数名称=参数值")方法,也可以用超链接:,页面跳转后,在目标页面中可用Ruquest["参数名称"]来接收参数。使用QuerySting 方法的优点是实现简单, 不使用服务器资源;缺点是传递的值会显示在浏览器的地址栏上,有...
  • C++中的指针参数传递和引用参数传递 指针参数传递本质上是值传递,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,会在栈中开辟内存空间以存放由主调函数传递进来的实参值...
  • 查询所有的pid并杀死。...1. 符号:` `名称:反引号,上分隔符位置:反引号(`)这个字符一般在键盘的左上角,数字1的左边,不要将其同单引号(’)混淆作用:反引号括起来的字符串被shell解释为命令行,在执...
  • 多页面之间传递数据的方法

    千次阅读 2018-08-07 16:14:25
    传统的前端开发中,页面之间是少有参数交互的,甚至没有,而在如今的前端环境下, 一个稍微正式点的项目都不可能少了...在JS中有多种页面传递参数的方法: 一、把参数值附在url后面传递到其他页面 如: ...
  • 1.关键字参数和默认值 请看下面两个函数: def hello_1(greeting, name):   print('{}, {}!'.format(greeting, name))  def hello_2(name, greeting):   print('{}, {}!'.format(name, greeting))  这两个...
  • 为什么Python类的方法需要加self作为第一个参数?比如Python类的方法都是这样定义的: 1 2 3 4 5 6 7 8 9 10 11 class CharField(Field): description...
  • vue获取参数的几种方式

    千次阅读 2022-01-13 21:18:54
    历史模式 用户体验 用户体验好,页面切换快 用户体验不好,页面切换慢 转场动画 容易实现 无法实现 数据传递 容易 依赖URL或本地存储 SEO 实现比较困难 简单 开发成本 难度高,需要借助专业的框架 难度低,但是重复...
  • 微软的.NET框架的优点之一是它提供了独立于语言的开发平台。你可以在VB、C++、C#等语言中编写一些类,而在其它语言中使用(源于.NET中使用了...这也就是说,你的参数必须被marshal(注:不知道中文名称该叫什么,英文中
  • 函数参数的几种形式及其相关

    千次阅读 2019-01-11 19:56:06
    形参即形式参数,就是在定义函数时括号中指定的参数,本质就是一个名字 实参即实际参数,指的是在调用函数的时候传入的参数,是一个实际的值 在调用函数式就会自动把形参(变量名)和实参(值)进行绑定, 在函数调用结束...
  • 第7.5节 揭开Python类中self的面纱

    千次阅读 2020-12-10 19:57:03
    使用一个标准的名称有很多优点——你的程序读者可以迅速识别它,如果使用self的话,还有些IDE(集成开发环境)也可以帮助你。 最后有个问题,Python中实例方法第一个参数是“self”,但它又是可以任意命名的,那怎么...
  • 使用您自己的界面的优点是您可以使用更清楚地表明意图的名称。 #3楼 There's a public Web-accessible version of the Lambda-enabled Java 8 JavaDocs, linked from http://lambdafaq.org/lambda-resources . 从...
  • 参数名称=参数值")方法,也可以用超链接:,页面跳转后,在目标页面中可用Ruquest["参数名称"]来接收参数。使用QuerySting 方法的优点是实现简单, 不使用服务器资源;缺点是传递的值会显示在浏览器的地址栏上,...
  • wget命令使用及参数详解

    千次阅读 2019-08-13 11:14:13
    命令参数:启动参数:记录和输入文件参数:下载参数:目录参数:HTTP 选项参数:FTP 选项参数:递归下载参数:4.使用实例:实例1:使用wget下载单个文件实例2:使用wget -O下载并以不同的文件名保存实例3:使用wget...
  • Post方式与参数详解

    千次阅读 2018-09-25 09:52:35
    不能不兼容现有的模式,但又想支持json,焦点就是在参数的接收上,让其能够完美的兼容上述两种参数传递,这里可以从HttpMessageConverter着手,这个就是用来将请求的参数映射到spring mvc方法中的实体参数的。...
  • 页面间传递数据的几种方法

    千次阅读 2017-06-09 09:09:00
    优点在于它是轻量级的,不会给服务器带来任何负担。而它也有几个缺点:传递的信息仅限于简单的字符串,而且必须是合法的URL字符;信息是对用户是可见的,因而存在安全性问题;用户可能会尝试手动修改查询字符串,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,070
精华内容 42,028
关键字:

名称传递参数的优点