精华内容
下载资源
问答
  • 一、*args的使用方法 *args 用来将参数打包成tuple给函数体调用 def args_test(x, y, *args): print(x, y, args) args_test(1,2,3,4,5) 1 2 (3, 4, 5) 二、**kwargs的使用方法 **kwargs 打包关键字参数成dict给...
  • 主要介绍了Spring AOP中使用args表达式的方法,结合实例形式分析了spring面向切面AOP中使用args表达式具体步骤、相关实现技巧与操作注意事项,需要的朋友可以参考下
  • public static void main(String[] args) { SpringApplication.run(SpringbootApplication.class, args); } } 可以看到它的main方法上有参数args。 这时如果我们想在项目启动时传入参数到这个main方法,然后根据...
  • def fun_var_args(farg, *args): print ‘args:’, farg for value in args: print ‘another arg:’,value # *args可以当作可容纳多个变量组成的list或tuplefun_var_args(1, ‘two’, 3, None) #args: 1#another...
  • 原始代码:args = parser.parse_args() usage: ipykernel_launcher.py [-h] [--x_dim XDIM] [--h_dim HDIM] [--z_dim ZDIM] [--ratio RATIO] [--seed SEED] ipykernel_launcher.py: error: unrecognized arguments...
  • 主要介绍了python命令行解析之parse_known_args()函数和parse_args()使用介绍,需要的朋友可以参考下
  • launch_args-源码

    2021-03-21 21:31:11
    launch_args 目录 介绍 Flutter软件包,能够将args传递给Android或iOS应用程序。该插件目前仅支持Android和iOS,因为大多数其他平台直接将args提供给main功能。 用法 import 'package:flutter/material.dart' ; ...
  • args是用于可选参数的通用库。 它受到Dave Cheney的启发。 它也可以用于Go程序的Python“ kwargs”目的。 用法 可选参数是使用New及其类型变量定义的。 这些参数基本上是返回args.V类型的参数值的args.V 。 要使用...
  • __VA_ARGS__用法

    2018-02-05 14:03:51
    调试信息的输出方法有很多种, 例如直接用printf, 或者出错时使用perror, fprintf等将信息直接打印到终端上, 在Qt上面一般使用qDebug,而守护进程则一般是使用syslog将调试信息输出到日志文件中等等
  • Flink ParameterTool fromArgs源码分析

    千次阅读 2020-03-04 16:02:38
    final ParameterTool params = ParameterTool.fromArgs(args); hostname = params.has("hostname") ? params.get("hostname") : "localhost"; port = params.getInt("port"); } catch (Exception e) { System....

    一、源码路径

    java/org/apache/flink/streaming/examples/socket/SocketWindowWordCount.java
    

    二、源码

    /*
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements.  See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership.  The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License.  You may obtain a copy of the License at
     *
     * http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package org.apache.flink.streaming.examples.socket;
    
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.ReduceFunction;
    import org.apache.flink.api.java.utils.ParameterTool;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.windowing.time.Time;
    import org.apache.flink.util.Collector;
    
    /**
     * Implements a streaming windowed version of the "WordCount" program.
     *
     * <p>This program connects to a server socket and reads strings from the socket.
     * The easiest way to try this out is to open a text server (at port 12345)
     * using the <i>netcat</i> tool via
     * <pre>
     * nc -l 12345
     * </pre>
     * and run this example with the hostname and the port as arguments.
     */
    @SuppressWarnings("serial")
    public class SocketWindowWordCount {
    
       public static void main(String[] args) throws Exception {
    
          //链接主机名和端口
          // the host and the port to connect to
          final String hostname;//主机名
          final int port;//端口
          try {
             /**
              * 参数解析
              */
             final ParameterTool params = ParameterTool.fromArgs(args);
             hostname = params.has("hostname") ? params.get("hostname") : "localhost";
             port = params.getInt("port");
          } catch (Exception e) {
             System.err.println("No port specified. Please run 'SocketWindowWordCount " +
                "--hostname <hostname> --port <port>', where hostname (localhost by default) " +
                "and port is the address of the text server");
             System.err.println("To start a simple text server, run 'netcat -l <port>' and " +
                "type the input text into the command line");
             return;
          }
    
          // get the execution environment
          final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    
          // get input data by connecting to the socket
          DataStream<String> text = env.socketTextStream(hostname, port, "\n");
    
          // parse the data, group it, window it, and aggregate the counts
          DataStream<WordWithCount> windowCounts = text
    
                .flatMap(new FlatMapFunction<String, WordWithCount>() {
                   @Override
                   public void flatMap(String value, Collector<WordWithCount> out) {
                      for (String word : value.split("\\s")) {
                         out.collect(new WordWithCount(word, 1L));
                      }
                   }
                })
    
                .keyBy("word")//根据word字段分组(hash函数分组)
                .timeWindow(Time.seconds(5))//时间窗口设为5秒,即非活动阈值。
    
                .reduce(new ReduceFunction<WordWithCount>() {
                   @Override
                   public WordWithCount reduce(WordWithCount a, WordWithCount b) {
                      return new WordWithCount(a.word, a.count + b.count);
                   }
                });
    
          // print the results with a single thread, rather than in parallel
          windowCounts.print().setParallelism(1);
    
          env.execute("Socket Window WordCount");
       }
    
       // ------------------------------------------------------------------------
    
       /**
        * Data type for words with count.
        */
       public static class WordWithCount {
    
          public String word;
          public long count;
    
          public WordWithCount() {}
    
          public WordWithCount(String word, long count) {
             this.word = word;
             this.count = count;
          }
    
          @Override
          public String toString() {
             return word + " : " + count;
          }
       }
    }
    

    三、源码分析

    输入字符串参数的解析
    /**
     * 参数解析
     */
    final ParameterTool params = ParameterTool.fromArgs(args);
    

    编写ParameterTool测试类

    package org.apache.flink.api.java.utils;
    
    /**
     * ParameterTool测试类
     * linjie
     */
    public class testParameter {
       public static void main(String[] args) {
          args = new String[]{"-count","-1","-count2","-2"};
          final ParameterTool params = ParameterTool.fromArgs(args);
    
       }
    }
    

    调试进入ParameterTool,笔者已在源码处编写详细注释,重点关注NumberUtils.isNumber(args[i])

    /*
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements.  See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership.  The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License.  You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package org.apache.flink.api.java.utils;
    
    import org.apache.flink.annotation.Public;
    import org.apache.flink.annotation.PublicEvolving;
    import org.apache.flink.api.common.ExecutionConfig;
    import org.apache.flink.configuration.Configuration;
    import org.apache.flink.util.Preconditions;
    
    import org.apache.commons.lang3.math.NumberUtils;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.ObjectInputStream;
    import java.io.OutputStream;
    import java.io.Serializable;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Properties;
    import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * 这个类提供了用于从不同源读取和解析程序参数的简单实用方法
     * This class provides simple utility methods for reading and parsing program arguments from different sources.
     */
    @Public
    public class ParameterTool extends ExecutionConfig.GlobalJobParameters implements Serializable, Cloneable {
       private static final long serialVersionUID = 1L;
    
       protected static final String NO_VALUE_KEY = "__NO_VALUE_KEY";
       protected static final String DEFAULT_UNDEFINED = "<undefined>";
    
       public static ParameterTool fromArgs(String[] args) {
          final Map<String, String> map = new HashMap<>(args.length / 2);//因为args是键值对形式,所以这里map大小是args的一半
    
          //将args其中的key,value加入到map中的入口
          int i = 0;
          while (i < args.length) {
    
             /**
              * 获取key,key在args的索引是奇数
              */
             final String key;
             //例子:args[0] = --input-topic
             //startsWith("--"):判断参数前缀是否是--
             //key=args[0]从第二个位置到结束的字符
             if (args[i].startsWith("--")) {
                key = args[i].substring(2);
             } else if (args[i].startsWith("-")) {
                key = args[i].substring(1);
             } else {
                throw new IllegalArgumentException(
                   String.format("Error parsing arguments '%s' on '%s'. Please prefix keys with -- or -.",
                      Arrays.toString(args), args[i]));
             }
    
             if (key.isEmpty()) {
                throw new IllegalArgumentException(
                   "The input " + Arrays.toString(args) + " contains an empty argument");
             }
    
             /**
              * 获取value,value在args的索引是偶数,索引i+=1
              */
             //关于NumberUtils.isNumber(args[i])对value值的判断目的如下:
             //NumberUtils.isNumber(args[i]):因为key是可能没有value的:new String[]{"--input","--output"},这样也是可以的
             //input=NO_VALUE_KEY
             //output=NO_VALUE_KEY
             //如果args是这样的:new String[]{"-count","-1"}
             //如果没有NumberUtils.isNumber(args[i])判断
             //count=NO_VALUE_KEY
             //1=NO_VALUE_KEY
             //但如果有NumberUtils.isNumber(args[i])判断
             //结果就是count=-1
             //new String[]{"-count","-1","-count2","-2"}
             i += 1; // try to find the value
    
             if (i >= args.length) {
                map.put(key, NO_VALUE_KEY);
             } else if (NumberUtils.isNumber(args[i])) {
                map.put(key, args[i]);
                i += 1;
             } else if (args[i].startsWith("--") || args[i].startsWith("-")) {
                // the argument cannot be a negative number because we checked earlier
                // -> the next argument is a parameter name
                map.put(key, NO_VALUE_KEY);
             } else {
                map.put(key, args[i]);
                i += 1;
             }
          }
    
          return fromMap(map);
       }
    
    展开全文
  • Python 讲堂 parse_args()详解

    万次阅读 多人点赞 2018-12-28 12:00:32
    # 4属性给与args实例: 把parser中设置的所有"add_argument"给返回到args子类实例当中, 那么parser中增加的属性内容都会在args实例中,使用即可。 args = parser.parse_args() parser.parse_args() # 打印定位参数...

    本文是对下面链接博客的补充与修正,全部代码我已经跑过,都是没有错误的。
                                                                                                                        ——Archerzjc

    0_此博客解释很详细 

    本文绝大多数参考此博客:https://ganler.github.io/2018/07/18/argsparse-python%E5%92%8C%E5%91%BD%E4%BB%A4%E8%A1%8C%E4%B9%8B%E9%97%B4%E7%9A%84%E4%BA%A4%E4%BA%92/

    关于dest可以从如下博客找到资料:
    http://www.cnblogs.com/zknublx/p/6106343.html
    https://blog.csdn.net/guoyajie1990/article/details/76739977

     

    此博主写的也不错,有时间可以看下:
    https://blog.csdn.net/u013177568/article/details/62432761/

     

    1. 初始化

    # 1引入模块
    import argparse  
       
    # 2建立解析对象
    parser = argparse.ArgumentParser()
    
    # 3增加属性:给xx实例增加一个aa属性 # xx.add_argument("aa")
    parser.add_argument("echo")         
    
    # 4属性给与args实例: 把parser中设置的所有"add_argument"给返回到args子类实例当中, 那么parser中增加的属性内容都会在args实例中,使用即可。
    args = parser.parse_args()
    parser.parse_args()
    
    # 打印定位参数echo
    print(args.echo)    
    

    运行的话,在 python argp.py 后面加上 abcd (任意);
    其将输出 “abcd”。
    因为我们把 abcd 赋给了 args.echo了。

    给其设置help:
    parser.add_argument("echo", help = "echo is here~")

    在命令行中输入:
    python argp.py -h
    就可以得到相关的帮助信息。

     

    2. type:

    假设我们写一个文件,在命令行将其编译时,同时输入一个数字,返回一个平方:
    因为 parse.add_argument() 对于接受的值默认其为str,如果要将之视为int类型,额外加一句 “type=int”。

    # 1引入模块
    import argparse
    
    # 2建立解析对象
    parser = argparse.ArgumentParser()
    
    # 3增加属性:在命令行中,该py文件希望用户能给他一个参数,最终将之转化为:args.square
    parser.add_argument("square", help = "To sqaure the number given", type = int)
    
    # 4属性给与args实例:add_argument 返回到 args 子类实例
    args = parser.parse_arg()
    print(args.square**2)

    有了type程序也可以自动过滤掉相关的不符合类型的参数输入。

     

    3. 可选参数:

     add_argument 前,给属性名之前加上“- -”,就能将之变为可选参数

    # 1引入模块
    import argparse
    
    # 2建立解析对象
    parser = argparse.ArgumentParser()
    
    # 3增加属性:这里的bool是一个可选参数,返回给args的是 args.bool
    parser.add_argument("--bool",help = "Whether to pirnt sth.")
    
    # 4属性给与args实例: parser中增加的属性内容都在args实例中
    args = parser.parse_args()
    
    # 如果有输入内容,则打印1
    if args.bool:
        print('bool = 1')

    ---输入:
    python argp.py --bool 1
    ---得到:
    bool = 1

    可选参数"--bool":
    既然是可选的,如果不指定(就是不使用它)的话,对应的变量会被设置为None
    对于简单程序,我们可能只需要两种值 True or    False

    action = "store_true" 默认操作True :
    我们可以在原有的程序的基础上,在 add_argument 中多加一个参数:
    action = "store_true"
    这个时候,只要在命令行中加个--bool,args.bool就是 True 了,无需再加上之后的赋值内容,加了反而会报错
    ---输入:
    python argp.py --bool 
    ---得到:
    bool = 1

    required=True :
    但是,如果在 parser.add_argument(..., action = "store_true",required=True) 的话,那么这个参数就是必须的,因为他是required
    ps: 这里指的参数是 --bool 必须写不然会报错
    ---输入:
    python argp.py --bool
    ---得到:
    bool = 1

     

    4.参数简写:

    parser.add_argument("-b","--bool",action="store_true")
    这样,在程序内部我们依旧使用 args.bool,但是在命令行当中我们只需要多写一个“-b”就好了。
    ---输入:
    python argp.py -b
    ---得到:
    bool = 1

     

    5.混合定位参数和可选参数:

    当我们使用多个 parser.add_argument(...) 的时候,若将之视为可选参数,无则为None

    # 1引入模块
    import argparse
    
    # 2建立解析对象
    parser = argparse.ArgumentParser()
    
    # 3增加属性
    parser.add_argument("-b","--bool",help="to show the ans in a sentencen form",action = "store_true")
    
    parser.add_argument("square", type=int)
    
    # 4属性赋予实例args
    args = parser.parse_args() 
    
    ans = args.square**2
    
    # 得到的效果为:一旦输入“-b”然后再输入相关的参数,就可以得到我们需要的结果了,不输入“-b”我们还是可以得到结果,只不过是另外一种方式而已。
    if args.bool:
        print("the square of {} = {}".format(args.square,ans))
    else:
        print(ans)
    

    ---输入:
    python test.py -b 2   (或者  python test.py 2)
    ---得到:
    4

    关于.format的使用方式请参考我的另一个format详解博客https://blog.csdn.net/zjc910997316/article/details/86571407

    如下内容需进一步了解,进阶:

    • 限制输入的值:

    如 parser.add_argument("-b", "--bool", choices = [0,1,2], help="you can only input 0 1or 2.", type = int)
    其中,choice 可以限定我们能够输入的数为0,1,2其中一个。
    这里的 type = int 必不可少,不然会报错。

    import argparse
    
    parser = argparse.ArgumentParser()
    
    parser.add_argument("-b", "--bool", choices = [0,1,2], type = int )
    
    args = parser.parse_args() 
    
    ans = args.bool**2
    
    print(ans)

    ---输入:
    python test.py -b 2   
    ---得到:
    4

    • 参数值和顺序:

    一般我们要把可选参数最后add不可选参数放前面add。
    而在命令行里面输入代码时,程序会先赋值“先add的参数选项”


    比如我先 parser.add_argument(“a”,…) 再b;
    输入命令行的时候: python xx.py x y,这个时候, args.a=x ; args.b=y。

    • count操作计数赋值:
    import argparse
    
    parser = argparse.ArgumentParser()
    
    parser.add_argument("-a", "--bool", action = "count")
    
    args = parser.parse_args() 
    
    ans = args.bool**2
    
    print(ans)

    ---输入:
    python test.py -aaa    
    ---得到:
    9

    parser.add_argument("-b", "--bool", action="count",type=int)   
    PS:这里千万不要加 type=int 不然会报错

    这个时候,在命令后加上 -b ——> bool=1 ;  -bb ——> bool=2 ; -bbb ——> bool=3 以此类推。

     

    但是这样的话,如果在程序里拿bool作为比较对象的时候,比如 if bool > 0: ,

    import argparse
    
    parser = argparse.ArgumentParser()
    
    parser.add_argument("-a", "--bool", action = "count")
    
    args = parser.parse_args() 
    
    ans = args.bool**2
    if bool:
        print(ans)

    ---输入: python test.py
    不写“-b”的时候会报错,原因是此时的bool是 None ,无法比较,

    import argparse
    
    parser = argparse.ArgumentParser()
    
    parser.add_argument("-a", "--bool", action = "count", default=0)
    
    args = parser.parse_args() 
    
    ans = args.bool**2
    if bool:
        print(ans)

    要解决这个问题我们只需要加上一个 default  选项:
    parser.add_argument("-b", "--bool", action="count", type=int, default=0) 就好了。
    ---输入: python test.py
    ---输出:0

     

    6.高级用法:

    光上面那点知识,怕是根本算不上炫酷。我们肯定需要更牛逼的办法。

    • 一个py文件的文件名字为"__file__"
    • 参数冲突:

    我们可以通过 group 方法,来让 group 组的参数不可以被同时指定:

    # 1导入模块
    import argparse
    
    # 2建立解析对象
    parser = argparse.ArgumentParser()
    
    # 3添加属性
    group = parser.add_mutually_exclusive_group()
    group.add_argument("-f", "--form", action="store_true")
    group.add_argument("-F", "--Form", action="store_true")
    parser.add_argument("x", type = float)  // python __file__.py -x 10 , 这个前面“x”不需要写成"-x"??
    parser.add_argument("y", type = float)
    
    # 4属性赋予实例args
    args = parser.parse_args()
    ans = args.x**args.y
    
    if args.form:
        print("{} to the power {} equals {}".format(args.x, args.y, ans))
    elif args.Form:
        print("{}^{} = {}".format(args.x,args.y,ans))
    else:
        print(ans)

    帮助信息中若有“ [a | b] ”就意味着,ab不可以同时使用。

     

    注意点:

    • 参数简写的时候不要定义“-h”,这个是给help用的
    • 如果你设置了几个同类型(比如int)的可选参数,并且给他们简写参数了,比如:

    x -> -x ; y -> -y …
    那么在命令行赋值的时候就应该写:
    python __file__ -x 10 -y 100
    x = 10 ; y = 100 ;

     

    常用的参数:

    dest:如果提供dest,例如dest="a"那么可以通过args.a访问该参数

    default:设置参数的默认值

    action:参数出发的动作

    store:保存参数,默认

    store_const:保存一个被定义为参数规格一部分的值(常量),而不是一个来自参数解析而来的值。

    store_ture/store_false:保存相应的布尔值

    append:将值保存在一个列表中。

    append_const:将一个定义在参数规格中的值(常量)保存在一个列表中。

    count:参数出现的次数

    parser.add_argument("-v", "--verbosity", action="count", default=0, help="increase output verbosity")

    version:打印程序版本信息

    type:把从命令行输入的结果转成设置的类型

    choice:允许的参数值

    parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2], help="increase output verbosity")

    help:参数命令的介绍

     

    7.dest:

    http://www.cnblogs.com/zknublx/p/6106343.html

    dest:如果提供dest,例如dest="a"那么可以通过args.a访问该参数
    dest 允许自定义ArgumentParser的参数属性名称

    如下例子,Example 0

    # 改进sort:
    # 用于被我验证这部分的使用方法
    
    # 1导入模块
    import argparse
    # 2建立解析对象
    parser = argparse.ArgumentParser(description='SORT demo')
    # 3添加属性
    parser.add_argument('--display', dest='display', help='Display online tracker output (slow) [False]',action='store_true')
    # 4属性赋予实例args
    args = parser.parse_args()
    print("{}".format(args.display))

    在文件位置打开终端输入 python test.py --display

    ‘--display’是可选选项,也可以不输入,直接 python test.py

    PS:后面三个例子暂时没看懂

    Example 1

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('bar')
    >>> parser.parse_args('XXX'.split())
    Namespace(bar='XXX')

    Example 2

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('-f', '--foo-bar', '--foo')
    >>> parser.add_argument('-x', '-y')
    >>> parser.parse_args('-f 1 -x 2'.split())
    Namespace(foo_bar='1', x='2')
    >>> parser.parse_args('--foo 1 -y 2'.split())
    Namespace(foo_bar='1', x='2')

    Example 3

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', dest='bar')
    >>> parser.parse_args('--foo XXX'.split())
    Namespace(bar='XXX')

     

     

    原博客地址:https://ganler.github.io/2018/07/18/argsparse-python%E5%92%8C%E5%91%BD%E4%BB%A4%E8%A1%8C%E4%B9%8B%E9%97%B4%E7%9A%84%E4%BA%A4%E4%BA%92/

    1_操作说明:
    背景:我安装了Anaconda, 在win7下, 把.py文件放置在桌面,用pyhton运行它

    一:
    win+R打开运行,输入cmd打开终端
    备注:win7可以在指定文件夹内 shift+右键 ->选择在“此处打开命令窗口”,即可在指定位置打开终端。

    运行.py文件,以下述代码为例:


    此文件在桌面,内容如下:

    # 1引入模块
    import argparse  
       
    # 2建立解析对象
    parser = argparse.ArgumentParser()
    
    # 3增加属性:给xx实例增加一个aa属性 # xx.add_argument("aa")
    parser.add_argument("echo")         
    
    # 4属性给与args实例: 把parser中设置的所有"add_argument"给返回到args子类实例当中, 那么parser中增加的属性内容都会在args实例中,使用即可。
    args = parser.parse_args()
    parser.parse_args()
    
    # 打印定位参数echo
    print(arg.echo)    
    

    二:

    此文件如何得到记录过程:
    win+R  ->  cmd -> 输入 jupyter notebook 打开了jupyter ->如下操作

    双击此处,改名如下

    输入代码如下:

    保存为test.py:

    选择地址保存即可。

    三:运行此 test.py 文件

     

    方法1:开始->搜索“python.exe”->拖拽过去-> 输入空格

    ->再拖拽.py文件

    ->输入空格->输入要打印内容比如 qwe

    因为此文件运行方法如此,注意:红色地方敲空格,蓝线上面是要打印内容

     

     

    方法2:
    打开终端->输入python->空格->拖入test.py文件
    因为添加了环境变量,所以直接输入python 就可以,系统可以找到它。

     

    方法3:  
    CD到 test.py 文件目录下 ->  python test.py qwe   (python ./test.py qwe 也是可以的)
    即可执行文件输出 qwe

    备注:关于如何敲代码cd到指定位置?

    1.切换盘符 :   
    D:

    2.进入D盘内的文件 :   
    cd 文件名

    3.撤回上一级目录:

    cd..

    4.查看当前目录下文件:

    dir

     

     

     

    2_后面是另外的一些相关博客,没有前面的详细,但有帮助理解
    parse_args()

    https://blog.csdn.net/daydayjump/article/details/80493024

    我对与文档的理解是,parse_args()是将之前add_argument()定义的参数进行赋值,并返回相关的namespace。

    Convert argument strings to objects and assign them as attributes of the namespace.

    Return the populated namespace.

    >>> parser = argparse.ArgumentParser(prog='PROG')
    >>> parser.add_argument('-x')
    >>> parser.add_argument('--foo')
    >>> parser.parse_args(['-x', 'X'])
    Namespace(foo=None, x='X')
    >>> parser.parse_args(['--foo', 'FOO'])
    Namespace(foo='FOO', x=None)
    

     

     

     

    3_补充:在python中,命令行解析的很好用

    1 导入命令行解析模块

    import argparse
    import sys

    2 然后创建对象

    parse = argparse.ArgumentParser()

    3 然后增加命令行

    parse.add_argument ("--learning_rate", type=float, default=0.01, help="initial learining rate")
    parse.add_argument ("--max_steps", type=int, default=2000, help="max")
    parse.add_argument ("--hidden1", type=int, default=100, help="hidden1")

    # 对于函数 add_argument() 第一个是选项, 第二个是数据类型, 第三个默认值, 第四个是help命令时的说明

    然后用 arg=parse.parse_args( sys.argv[1:] )

    其中参数 sys.argv[1:] 是命令行语句中 从第一个到最后。
    如在ubuntu下输入命令行python gg.py --learning_rate 20 --max_steps 10

    则 sys.argv[1:0] = --learning_rate 20 --max_steps 10

    输出的arg为namespace空间,结果是 Namespace (hidden1=100, learning_rate=20.0, max_steps=10)
    但是parse_known_args()函数输出结果为

    te 20 --max_steps 10
    20.0
    10
    100

     

     

     

    程序:

    import argparse
    import sys

    parse=argparse.ArgumentParser()
    parse.add_argument("--learning_rate",type=float,default=0.01,help="initial learining rate")
    parse.add_argument("--max_steps",type=int,default=2000,help="max")
    parse.add_argument("--hidden1",type=int,default=100,help="hidden1")
    flags,unparsed=parse.parse_known_args(sys.argv[1:])
    print flags.learning_rate
    print flags.max_steps
    print flags.hidden1
    print unparsed

    输出结果:

    20.0
    10
    100
    []

    程序:

    20.0
    10
    100
    这两个函数的功能差不多
     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 调用函数时使用*和 **假设有函数def test(a, b, c)test(*args):* 的作用其实就是把序列 args 中的每个元素,当作位置参数传进去。比如上面这个代码,如果 args 等于 (1,2,3) ,那么这个代码就等价于 test(1, 2, 3) ...

    调用函数时使用*和 **

    假设有函数

    def test(a, b, c)

    test(*args):* 的作用其实就是把序列 args 中的每个元素,当作位置参数传进去。比如上面这个代码,如果 args 等于 (1,2,3) ,那么这个代码就等价于 test(1, 2, 3) 。

    test(**kwargs):** 的作用则是把字典 kwargs 变成关键字参数传递。比如上面这个代码,如果 kwargs 等于 {‘a’:1,’b’:2,’c’:3} ,那这个代码就等价于 test(a=1,b=2,c=3) 。

    定义函数参数时使用*和**

    def test(*args):

    定义函数参数时 * 的含义又要有所不同,在这里 *args 表示把传进来的位置参数都装在元组 args 里面。比如说上面这个函数,调用 test(1, 2, 3) 的话, args 的值就是 (1, 2, 3) 。:

    def test(**kwargs):

    类似的, ** 就是针对关键字参数和字典的了。 调用 test(a=1,b=2,c=3) 的话, kwargs 的值就是 {‘a’:1,’b’:2,’c’:3} 了。

    #*args的用法:当传入的参数个数未知,且不需要知道参数名称时。

    def func_arg(farg, *args):

    print("formal arg:", farg)

    for arg in args:

    print("another arg:", arg)

    func_arg(1,"youzan",'dba','四块五的妞')

    print("-----------------------")

    # 输出结果如下:

    # formal arg: 1

    # another arg: youzan

    # another arg: dba

    # another arg: 四块五的妞

    # -----------------------

    #**args的用法:当传入的参数个数未知,但需要知道参数的名称时(立马想到了字典,即键值对)

    def func_kwargs(farg, **kwargs):

    print("formal arg:", farg)

    for key in kwargs:

    print("keyword arg: %s: %s" % (key, kwargs[key]))

    func_kwargs(1 ,id=1, name='youzan', city='hangzhou',age ='20',四块五的妞是 = '来日方长的')

    print('--------------------')

    # 输出结果如下:

    # formal arg: 1

    # keyword arg: id: 1

    # keyword arg: name: youzan

    # keyword arg: city: hangzhou

    # keyword arg: age: 20

    # keyword arg: 四块五的妞是: 来日方长的

    #利用它转换参数为字典

    def kw_dict(**kwargs):

    return kwargs

    print(kw_dict(a=1,b=2,c=3))

    # 输出结果如下:

    # --------------------

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

    展开全文
  • Spring-AOP @AspectJ切点函数之args()和@args()

    万次阅读 热门讨论 2017-08-31 08:48:21
    args概述args函数的入参是类名, 而 @args()的入参必须是注解类的类名。 虽然args()允许在类名后使用“+”通配符,但该通配符在此处没有意义,添加和不添加的效果都一样。args()该函数接收一个类名,表示目标类方法...

    概述

    args函数的入参是类名, 而 @args()的入参必须是注解类的类名。

    虽然args()允许在类名后使用“+”通配符,但该通配符在此处没有意义,添加和不添加的效果都一样。

    args()

    该函数接收一个类名,表示目标类方法入参对象是指定类(包含子类)时,切点匹配。

    比如args(com.xgj.Waiter) 表示运行时入参是Waiter类型的方法,它和execution(* *(com.xgj.Waiter))的区别在于后者是这对类方法的签名而言的,而前者是针对运行时的入参类型而言。

    比如args(com.xgj.Waiter)既匹配addWiter(Waiter waiter),又匹配addNaiveWaiter(NaiveWaiter waiter); 而 execution(* *(com.xgj.Waiter)),实际上 args(com.xgj.Waiter)等价于 execution(* *(com.xgj.Waiter+)),当然也等价于 args(com.xgj.Waiter+)


    @args()

    该函数接收一个注解类的类名,当方法的运行时入参对象标注了指定的注解时,匹配切点。

    我们来通过下图@args(M)匹配示意图来详细解释下:

    这里写图片描述

    T0、T1、T2、T3有如上继承关系,假设目标类方法的签名为fun(T1 t),它的入参为T1,而切面的切点定义为@args(M), T2类标注了@M。 当fun(T1 t)的传入对象为T2或者T3时,方法匹配@args(M)声明所定义的切点。

    假设方法签名是funt(T1 t),入参为T1,而标注了@M的类是T0,当fun(T1 t)传入T1、T2、T3的实例时,均不匹配切点@args(M).

    在类的继承树中,(1)处为方法签名中入参类型在继承树的位置,称之为入参类型点, 而(2)处标注了@M注解的类在类继承树中的位置,称之为注解点。 判断方法在运行时是否匹配@args(M)切点,可以根据(1)和(2)在类继承树中的相对位置来判断。

    • 如果在继承树中注解点(2)高于入参类型点(1),则该目标方法不可能匹配到切点@args(M) ,如下图所示

    这里写图片描述

    • 如果在类继承树中注解点(2)低于入参类型点(1),则注解点所在类及其子孙类作为方法入参时,该方法匹配切点@args(M)

    实例请参考下文。


    实例

    代码已托管到Github—> https://github.com/yangshangwei/SpringMaster

    args()

    在这里插入图片描述

    POJO

    package com.xgj.aop.spring.advisor.aspectJ.function.args;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class UserService {
    
    	public void addUser(User user) {
    		System.out.println("addUser " + user);
    	}
    
    	public void modifyUser(User user) {
    		System.out.println("modifyUser " + user);
    	}
    
    	public void delUser(User user) {
    		System.out.println("delUser " + user);
    	}
    
    	/**
    	 * 
    	 * 
    	 * @Title: addArtisanTT
    	 * 
    	 * @Description: 入参为ArtisanTT
    	 * 
    	 * @param artisan
    	 * 
    	 * @return: void
    	 */
    	public void addArtisanTT(ArtisanTT artisan) {
    		System.out.println("addArtisanTT " + artisan);
    	}
    
    	public void modifyArtisanTT(ArtisanTT artisan) {
    		System.out.println("modifyArtisanTT " + artisan);
    	}
    
    	public void delArtisanTT(ArtisanTT artisan) {
    		System.out.println("delArtisanTT " + artisan);
    	}
    
    }
    
    

    POJO

    package com.xgj.aop.spring.advisor.aspectJ.function.args;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class UserServiceExt {
    	public void addUser(User user) {
    		System.out.println("入参为user的类  addUser " + user);
    	}
    
    	public void modifyUser(User user) {
    		System.out.println("入参为user的类   modifyUser " + user);
    	}
    
    	public void delUser(User user) {
    		System.out.println("入参为user的类  delUser " + user);
    	}
    
    	/**
    	 * 
    	 * 
    	 * @Title: addArtisanTT
    	 * 
    	 * @Description: 入参为ArtisanTT
    	 * 
    	 * @param artisan
    	 * 
    	 * @return: void
    	 */
    	public void addArtisanTT(ArtisanTT artisan) {
    		System.out.println("addArtisanTT " + artisan);
    	}
    
    	public void modifyArtisanTT(ArtisanTT artisan) {
    		System.out.println("modifyArtisanTT " + artisan);
    	}
    
    	public void delArtisanTT(ArtisanTT artisan) {
    		System.out.println("delArtisanTT " + artisan);
    	}
    }
    
    
    

    切面

    package com.xgj.aop.spring.advisor.aspectJ.function.args;
    
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    /**
     * 
     * 
     * @ClassName: ArgsAspectJ
     * 
     * @Description: 该函数接收一个类名,表示目标类方法入参对象是指定类(包含子类)时,切点匹配
     * 
     * @author: Mr.Yang
     * 
     * @date: 2017年9月1日 上午11:36:23
     */
    
    @Aspect
    public class ArgsAspect {
    
    	@Before("args(com.xgj.aop.spring.advisor.aspectJ.function.args.User)")
    	public void crossCuttingCode() {
    		System.out.println("some logic is here ");
    	}
    }
    

    配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/aop
    		http://www.springframework.org/schema/aop/spring-aop.xsd
    		http://www.springframework.org/schema/context 
           	http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.aop.spring.advisor.aspectJ.function.args"/>
    
    
     
    <!-- 基于@AspectJ切面的驱动器 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
     
    
    
    <!-- 使用了@AspectJ注解的切面类 -->
    <bean class="com.xgj.aop.spring.advisor.aspectJ.function.args.ArgsAspect"/>
    
    </beans>
    

    测试类:

    package com.xgj.aop.spring.advisor.aspectJ.function.args;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class ArgsAspectTest {
    
    	private ApplicationContext ctx;
    
    	@Test
    	public void test() {
    		ctx = new ClassPathXmlApplicationContext("classpath:com/xgj/aop/spring/advisor/aspectJ/function/args/conf-args.xml");
    		UserService userService = ctx.getBean("userService", UserService.class);
    		UserServiceExt userServiceExt = ctx.getBean("userServiceExt", UserServiceExt.class);
    
    		User user = new User();
    		ArtisanTT artisan = new ArtisanTT();
    
    		// 织入横切逻辑
    		userService.addUser(user);
    		// 织入横切逻辑
    		userService.modifyUser(user);
    		// 织入横切逻辑
    		userService.delUser(user);
    
    		System.out.println("================================");
    		// 入参不是user,因此不会被织入横切逻辑
    		userService.addArtisanTT(artisan);
    		userService.modifyArtisanTT(artisan);
    		userService.delArtisanTT(artisan);
    
    		System.out.println("================================");
    
    		// 入参为user,因此也会被织入横切逻辑
    		userServiceExt.addUser(user);
    		// 入参为user,因此也会被织入横切逻辑
    		userServiceExt.modifyUser(user);
    		// 入参为user,因此也会被织入横切逻辑
    		userServiceExt.delUser(user);
    		System.out.println("================================");
    
    		// 入参不是user,因此不会被织入横切逻辑
    		userServiceExt.addArtisanTT(artisan);
    		userServiceExt.modifyArtisanTT(artisan);
    		userServiceExt.delArtisanTT(artisan);
    
    	}
    }
    
    
    

    运行结果:

    2018-01-04 09:19:50,614  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@4a05bc0c: startup date [Thu Jan 04 09:19:50 CST 2018]; root of context hierarchy
    2018-01-04 09:19:50,795  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/aop/spring/advisor/aspectJ/function/args/conf-args.xml]
    some logic is here 
    addUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
    some logic is here 
    modifyUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
    some logic is here 
    delUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
    ================================
    addArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
    modifyArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
    delArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
    ================================
    some logic is here 
    入参为user的类  addUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
    some logic is here 
    入参为user的类   modifyUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
    some logic is here 
    入参为user的类  delUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
    ================================
    addArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
    modifyArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
    delArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
    
    
    

    @args()

    首先我们先自定义一个注解,用于测试用

    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 
     * 
     * @ClassName: Monitor
     * 
     * @Description: 自定义注解 @Monitor
     *               更多信息请阅读http://blog.csdn.net/yangshangwei/article/
     *               details/77477840
     * 
     * @author: Mr.Yang
     * 
     * @date: 2017年9月1日 下午4:00:12
     */
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ ElementType.TYPE, ElementType.METHOD })
    @Documented
    public @interface Monitor {
    
    	public boolean value() default true;
    }
    
    

    使用注解扫描的4个POJO

    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class T0 {
    
    }
    
    
    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class T1 extends T0 {
    
    	/**
    	 * 
    	 * 
    	 * @Title: fun
    	 * 
    	 * @Description: 目标类方法,旨在这个方法中织入增强逻辑. 当注解标注在T2,方法的入参为T2或者T2的子孙类时,会织入增强
    	 * 
    	 * @param t
    	 * 
    	 * @return: void
    	 */
    	public void fun(T2 t) {
    		System.out.println(t.getClass().getName() + " fun executed");
    	}
    }
    
    
    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.springframework.stereotype.Component;
    
    @Monitor
    @Component
    public class T2 extends T1 {
    
    }
    
    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class T3 extends T2 {
    
    }
    
    

    切面

    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    /**
     * 
     * 
     * @ClassName: AtArgsAspect
     * 
     * @Description: 标注了@Aspect的切面
     * 
     * @author: Mr.Yang
     * 
     * @date: 2017年9月1日 下午4:21:14
     */
    
    @Aspect
    public class AtArgsAspect {
    
    	@Before("@args(com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.Monitor)")
    	public void crossCuttingCode() {
    		System.out.println("前置增强 横切逻辑织入 some logic is here ");
    	}
    }
    
    

    配置文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/aop
    		http://www.springframework.org/schema/aop/spring-aop.xsd
    		http://www.springframework.org/schema/context 
           	http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.aop.spring.advisor.aspectJ.function.args.atargs"/>
     
    <!-- 基于@AspectJ切面的驱动器 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    
    <!-- 使用了@AspectJ注解的切面类 -->
    <bean class="com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.AtArgsAspect"/>
    
    </beans>
    
    

    测试类

    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AtArgsAspectTest {
    
    	@Test
    	public void test() {
    		ApplicationContext ctx = new ClassPathXmlApplicationContext(
    				"classpath:com/xgj/aop/spring/advisor/aspectJ/function/args/atargs/conf-atargs.xml");
    
    		T0 t0 = ctx.getBean("t0", T0.class);
    		T1 t1 = ctx.getBean("t1", T1.class);
    		T2 t2 = ctx.getBean("t2", T2.class);
    		T3 t3 = ctx.getBean("t3", T3.class);
    
    		// 因t1中的fun入参为t2,且注解标注在了T2类上,t3又是t2的子类,所以 下面两个调用都会织入增强
    		t1.fun(t2);
    		t1.fun(t3);
    
    	}
    }
    
    

    运行结果:

    2017-09-04 17:43:44,302  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@f4efcb0: startup date [Mon Sep 04 17:43:44 BOT 2017]; root of context hierarchy
    2017-09-04 17:43:44,390  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/aop/spring/advisor/aspectJ/function/args/atargs/conf-atargs.xml]
    前置增强 横切逻辑织入 some logic is here 
    com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T2$$EnhancerBySpringCGLIB$$fcff1873 fun executed
    前置增强 横切逻辑织入 some logic is here 
    com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T3$$EnhancerBySpringCGLIB$$109aa116 fun executed
    
    

    从运行结果看,正确的织入了横切逻辑。

    在类继承树中注解点低于入参类型点,则注解点所在类及其子孙类作为方法入参时,该方法匹配切点@args(M), 符合。


    如果我们先取消掉T2上的@Monitor注解,然后把注解标注在T0上

    如下:

    package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;
    
    import org.springframework.stereotype.Component;
    
    @Monitor
    @Component
    public class T0 {
    
    }
    
    

    运行结果:

    2017-09-04 17:56:31,858  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1c057a1e: startup date [Mon Sep 04 17:56:31 BOT 2017]; root of context hierarchy
    2017-09-04 17:56:31,970  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/aop/spring/advisor/aspectJ/function/args/atargs/conf-atargs.xml]
    com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T2$$EnhancerBySpringCGLIB$$42855f4c fun executed
    com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T3$$EnhancerBySpringCGLIB$$5620e7ef fun executed
    

    因在继承树中注解点高于入参类型点,因此该目标方法不可能匹配到切点@args(M)。

    展开全文
  • Python *args 用法笔记

    千次阅读 2020-07-25 10:22:15
    在 def 语句中使用 *args,即可令函数接受数量可变的位置参数。 比如确定一个函数接收 message 信息参数和 values 值参数,但不确定 values 有几个值,解决方法可以把 values 定义成列表,有数据就塞入列表,无数据...
  • 手工写实在太多了,而且容易出错,于考虑用可变参数宏:__VA_ARGS__ 来实现,关键就是要实现对__VA_ARGS__中每个参数元素的遍历。 下面是现实代码,真正调用的宏只有一个FL_FOREACH, FL_FOREACH实现对__VA_...
  • Python中 *args,**args的详细用法

    千次阅读 2021-05-10 16:14:09
    *args 和 **kwargs主要用于函数定义,你可以将不定数量的参数传递给某个函数。 *args *args 不定参数(不定的意思是指,预先并不知道,函数使用者会传递多少个参数给你) *args是用来发送一个非键值对的可变数量的...
  • Python * args和** kwargs

    千次阅读 2020-07-10 09:54:52
    例如def add(a, b) Variable number of non-keyworded arguments using *args, for example def add(*args) 使用* args的可变数量的非关键字参数,例如def add(*args) Variable number of keyworded arguments or ...
  • 详解用Python处理Args的3种方法

    千次阅读 2021-04-26 17:26:23
    1. sys 模块Python 中的 sys 模块具有 argv 功能。当通过终端触发 main.py 的执行时,此功能将返回提供给 main.py 的...考虑下面的 main.py 示例import syslist_of_arguments = sys.argvprint(list_of_args[0])pri...
  • Args.js.zip

    2019-07-19 18:27:13
    Args.js 可以让你轻松创建支持可选参数、带默认参数、参数分组和命名参数的函数。 示例代码: function addBook() {  var args = Args([  {title: Args.STRING | Args.Required},  {description: Args....
  • args-util command args实用程序,用于指挥官或其他args解析器。 args-util可以帮助您向args添加一些验证器和值解析器。 安装 npm install args-util-保存
  • Python中函数的参数定义和可变参数*args与**args区别刚学用Python的时候,特别是看一些库的源码时,经常会看到func(*args,**kwargs)这样的函数定义,这个*和**让人有点费解。其实只要把函数参数定义搞清楚了,就不难...
  • #, ##, args...以及__VAR_ARGS__宏定义解析

    千次阅读 2018-07-19 10:52:17
    #define printf(format, args...) \   printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args) 更有甚者,在 man printf时候,都会有类似 点击(此处)折叠或打开 int printf(co...
  • 在具体使用Spring Boot的过程中,如果需要获得SpringApplication.run(args)方法传递的参数,那么可通过ApplicationArguments接口来获得。 使用方法非常简单,只用在需要获得参数的类中直接注入ApplicationArguments...
  • get-gulp-args-源码

    2021-06-08 09:55:40
    get-gulp-args 获取 gulp 命令的 cmd 参数 使用安装 npm install get-gulp-args 用法 gulp build --dev --main var args = require ( 'get-gulp-args' ) ( ) ; process . env . NODE_ENV = args [ 0 ] || 'dev' ; ...
  • # ## __VA_ARGS__ ##__VA_ARGS__的使用说明

    千次阅读 2020-06-04 18:56:53
    对# 、##、__VA_ARGS__和##__VA_ARGS__等预处理操作符的使用进行简单整理
  • python中*args **kw到底是什么意思?

    千次阅读 2021-01-26 16:04:43
    *args是非關鍵字參數,用於元組,**kw是關鍵字參數,用於字典def foo(*args, **kwargs): print 'args = ', args print 'kwargs = ', kwargs print '---------------------------------------'if __name__ == '__main...
  • JAVA中的String[] args和String args[]是什么意思?1、是什么意思?2、怎样给args赋值?3、补充事项 1、是什么意思? Java中的String[] args 和String args[]都可以运行,String[] args 和String args[]一般包含在...
  • parse_args()和parse_known_args()的用法和区别

    千次阅读 多人点赞 2019-10-17 21:06:33
    parse_args()和parse_known_args()的用法和区别 在使用python命令行解析包argparse的时候,遇到了parse_args()和parse_known_args()两种用法,遂查资料搞清楚两个函数的差别并记录。 parse_args() 直接举例子说明...
  • 本篇文章是对func_num_args与func_get_args函数的使用进行了详细的分析介绍,需要的朋友参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,372,638
精华内容 1,749,055
关键字:

args