python click module for command line interface
2015-05-29 00:01
711 查看
[b] Click Module(一)[/b]
[b] ----xiaojikuaipao[/b]
The following material was from the website :
http://click.pocoo.org/4/
1. click Arguments
website: http://click.pocoo.org/4/arguments/
Arguments work similarly to options but are positional. They also only support a subset of the features of options due to their syntactical nature. Click will also not attempt to document arguments for you and wants you to document them manually in order to avoid ugly help pages.
Example:
And what it looks like:
The value is then passed as a tuple. Note that only one argument can be set to
Example:
And what it looks like:
Note that this is not how you would write this application. The reason for this is that in this particular example the arguments are defined as strings. Filenames, however, are not strings! They might be on certain operating systems, but not necessarily on all. For better ways to write this, see the next sections.
1.3 Note on Non-Empty Variadic Arguments
If you come from
This is supported by setting
1.4 File Arguments
Since all the examples have already worked with filenames, it makes sense to explain how to deal with files properly. Command line tools are more fun if they work with files the Unix way, which is to accept
Click supports this through the
Example:
And what it does:
Instead, you should be using the
Example:
And what it does:
This behavior can be forced by passing
Since files opened for writing will typically immediately empty the file, the lazy mode should only be disabled if the developer is absolutely sure that this is intended behavior.
Forcing lazy mode is also very useful to avoid resource handling confusion. If a file is opened in lazy mode, it will receive a
Starting with Click 2.0, it is also possible to open files in atomic mode by passing
Example usage:
And from the command line:
In that case, it can also be a list of different environment variables where the first one is picked.
Generally, this feature is not recommended because it can cause the user a lot of confusion.
To solve this, Click does what any POSIX style command line script does, and that is to accept the string
Example usage:
And from the command line:
[b] ----xiaojikuaipao[/b]
The following material was from the website :
http://click.pocoo.org/4/
1. click Arguments
website: http://click.pocoo.org/4/arguments/
Arguments work similarly to options but are positional. They also only support a subset of the features of options due to their syntactical nature. Click will also not attempt to document arguments for you and wants you to document them manually in order to avoid ugly help pages.
1.1 Basic Arguments
The most basic option is a simple string argument of one value. If no type is provided, the type of the default value is used, and if no default value is provided, the type is assumed to beSTRING.
Example:
@click.command() @click.argument('filename') def touch(filename): click.echo(filename)
And what it looks like:
$ touch foo.txt foo.txt
1.2 Variadic Arguments
The second most common version is variadic arguments where a specific (or unlimited) number of arguments is accepted. This can be controlled with thenargsparameter. If it is set to
-1, then an unlimited number of arguments is accepted.
The value is then passed as a tuple. Note that only one argument can be set to
nargs=-1, as it will eat up all arguments.
Example:
@click.command() @click.argument('src', nargs=-1) @click.argument('dst', nargs=1) def copy(src, dst): for fn in src: click.echo('move %s to folder %s' % (fn, dst))
And what it looks like:
$ copy foo.txt bar.txt my_folder move foo.txt to folder my_folder move bar.txt to folder my_folder
Note that this is not how you would write this application. The reason for this is that in this particular example the arguments are defined as strings. Filenames, however, are not strings! They might be on certain operating systems, but not necessarily on all. For better ways to write this, see the next sections.
1.3 Note on Non-Empty Variadic Arguments
If you come from
argparse, you might be missing support for setting
nargsto
+to indicate that at least one argument is required.
This is supported by setting
required=True. However, this should not be used if you can avoid it as we believe scripts should gracefully degrade into becoming noops if a variadic argument is empty. The reason for this is that very often, scripts are invoked with wildcard inputs from the command line and they should not error out if the wildcard is empty.
1.4 File Arguments
Since all the examples have already worked with filenames, it makes sense to explain how to deal with files properly. Command line tools are more fun if they work with files the Unix way, which is to accept
-as a special file that refers to stdin/stdout.
Click supports this through the
click.Filetype which intelligently handles files for you. It also deals with Unicode and bytes correctly for all versions of Python so your script stays very portable.
Example:
@click.command() @click.argument('input', type=click.File('rb')) @click.argument('output', type=click.File('wb')) def inout(input, output): while True: chunk = input.read(1024) if not chunk: break output.write(chunk)
And what it does:
$ inout - hello.txt hello ^D $ inout hello.txt - hello
1.5 File Path Arguments
In the previous example, the files were opened immediately. But what if we just want the filename? The naïve way is to use the default string argument type. However, remember that Click is Unicode-based, so the string will always be a Unicode value. Unfortunately, filenames can be Unicode or bytes depending on which operating system is being used. As such, the type is insufficient.Instead, you should be using the
Pathtype, which automatically handles this ambiguity. Not only will it return either bytes or Unicode depending on what makes more sense, but it will also be able to do some basic checks for you such as existence checks.
Example:
@click.command() @click.argument('f', type=click.Path(exists=True)) def touch(f): click.echo(click.format_filename(f))
And what it does:
$ touch hello.txt hello.txt $ touch missing.txt Usage: touch [OPTIONS] F Error: Invalid value for "f": Path "missing.txt" does not exist.
1.6 File Opening Safety
TheFileTypetype has one problem it needs to deal with, and that is to decide when to open a file. The default behavior is to be “intelligent” about it. What this means is that it will open stdin/stdout and files opened for reading immediately. This will give the user direct feedback when a file cannot be opened, but it will only open files for writing the first time an IO operation is performed by automatically wrapping the file in a special wrapper.
This behavior can be forced by passing
lazy=Trueor
lazy=Falseto the constructor. If the file is opened lazily, it will fail its first IO operation by raising an
FileError.
Since files opened for writing will typically immediately empty the file, the lazy mode should only be disabled if the developer is absolutely sure that this is intended behavior.
Forcing lazy mode is also very useful to avoid resource handling confusion. If a file is opened in lazy mode, it will receive a
close_intelligentlymethod that can help figure out if the file needs closing or not. This is not needed for parameters, but is necessary for manually prompting with the
prompt()function as you do not know if a stream like stdout was opened (which was already open before) or a real file that needs closing.
Starting with Click 2.0, it is also possible to open files in atomic mode by passing
atomic=True. In atomic mode, all writes go into a separate file in the same folder, and upon completion, the file will be moved over to the original location. This is useful if a file regularly read by other users is modified.
1.7 Environment Variables
Like options, arguments can also grab values from an environment variable. Unlike options, however, this is only supported for explicitly named environment variables.Example usage:
@click.command() @click.argument('src', envvar='SRC', type=click.File('r')) def echo(src): click.echo(src.read())
And from the command line:
$ export SRC=hello.txt $ echo Hello World!
In that case, it can also be a list of different environment variables where the first one is picked.
Generally, this feature is not recommended because it can cause the user a lot of confusion.
1.8 Option-Like Arguments
Sometimes, you want to process arguments that look like options. For instance, imagine you have a file named-foo.txt. If you pass this as an argument in this manner, Click will treat it as an option.
To solve this, Click does what any POSIX style command line script does, and that is to accept the string
--as a separator for options and arguments. After the
--marker, all further parameters are accepted as arguments.
Example usage:
@click.command() @click.argument('files', nargs=-1, type=click.Path()) def touch(files): for filename in files: click.echo(filename)
And from the command line:
$ touch -- -foo.txt bar.txt -foo.txt bar.txt
相关文章推荐
- python的subprocess模块
- Python学习总结之五 -- 入门函数式编程
- python实现简单抓图并打包成exe
- Python学习第三篇之pass的作用
- [笔记] 创建python中的字符串translator
- Python中下划线的使用方法
- python基础教程学习笔记---(4)字典
- python运算口诀
- Python 计算已经过去多少个周末
- 局部加权线性回归及岭回归之Python实现
- Python学习之路
- python重要的函数代码块
- Numpy快速处理数据--ufunc运算(三)
- python下输出指定年月日的方法之一
- Python学习_13_继承和元类
- 百度相册提取器(Python)
- PYTHON unitest模块
- python-如何创建二维数组
- 主成分分析法原理及其python实现
- Python ZKPython 安装