Python 命令行工具 argparse 模块使用详解

 

 

原文连接：https://www.cnblogs.com/piperck/p/8446580.html

先来介绍一把最基本的用法

import argparse


parser = argparse.ArgumentParser()
parser.parse_args()

在执行 parse_args() 以前，全部追加到命令行的参数都不会生效，生效了以后的默认状况相似于这样：

 

设置默认参数函数：

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print args.echo

当咱们须要设置一个默认参数使用的时候，咱们能够这么作达到的效果是这样的：

 第二行是我直接打印 print args 的效果。能够看到是一个 Namespace 对象。

当我直接输入 -h 参数的时候能够看到命令行会提示咱们 positional arguments 是 echo 是必填。

 

下面继续来定义可选参数

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
    print "verbosity turned on"

咱们看到的效果是这样的：

可见，若是用省略方法 -v 赋值的方法，最终会到达 --verbosity 值会传递到这个完整的参数中去。这里值得一提的是，若是没有后面的 --verbosity 只有 -v 的话，那么值会能够经过 args.v 获得。

 

固然也有能够不指定值的方法，可让此值直接默认设置为 bool 值，而使用 action='store_true' 能够作到

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbosity", help="increase output verbosity", action="store_true")
args = parser.parse_args()
print args.verbosity

得到的效果以下。

 

常规用法大体介绍了一把。下面咱们来看下具体的函数都作了哪些工做。

能够注意到咱们每次都会去初始化一把 ArgumentParser类，他的初始化定义以下：

class ArgumentParser(_AttributeHolder, _ActionsContainer):
    """Object for parsing command line strings into Python objects.

    Keyword Arguments:
        - prog -- The name of the program (default: sys.argv[0])
        - usage -- A usage message (default: auto-generated from arguments)
        - description -- A description of what the program does
        - epilog -- Text following the argument descriptions
        - parents -- Parsers whose arguments should be copied into this one
        - formatter_class -- HelpFormatter class for printing help messages
        - prefix_chars -- Characters that prefix optional arguments
        - fromfile_prefix_chars -- Characters that prefix files containing
            additional arguments
        - argument_default -- The default value for all arguments
        - conflict_handler -- String indicating how to handle conflicts
        - add_help -- Add a -h/-help option
    """

    def __init__(self,
                 prog=None,
                 usage=None,
                 description=None,
                 epilog=None,
                 version=None,
                 parents=[],
                 formatter_class=HelpFormatter,
                 prefix_chars='-',
                 fromfile_prefix_chars=None,
                 argument_default=None,
                 conflict_handler='error',
                 add_help=True):

• prog - 程序的名字（默认：sys.argv[0]）
• usage - 描述程序用法的字符串（默认：从解析器的参数生成）
• description - 参数帮助信息以前的文本（默认：空）
• epilog - 参数帮助信息以后的文本（默认：空）
• parents - ArgumentParser 对象的一个列表，这些对象的参数应该包括进去
• formatter_class - 定制化帮助信息的类
• prefix_chars - 可选参数的前缀字符集（默认：‘-‘）
• fromfile_prefix_chars - 额外的参数应该读取的文件的前缀字符集（默认：None）
• argument_default - 参数的全局默认值（默认：None）
• conflict_handler - 解决冲突的可选参数的策略（一般没有必要）
• add_help - 给解析器添加-h/–help 选项（默认：True）

 

咱们能够来看下经常使用必填参数都加上的效果

# coding: utf-8
import argparse

x = argparse.ArgumentParser(prog='It\'s a cool job!',
                            usage='正常使用我就能够了',
                            description='那你说个毛',
                            epilog='我是 EPILOG')
x.add_argument('-v', help='gg 斯密达')
x.parse_args()

 

值得注意的一点是，当我使用了 usage 的参数以后，他彷佛在一样的位置覆盖了 prog 参数里面的值。

其余几个设置比较少用到，若是要使用能够查询 refrence 1 里面的文档。也可直接访问官方文档查看用法。

 

下面重点说下 ArgumentParser.add_argument。不知道在 python 的哪一个版本，标准库调整了这个地方。目前在标准库里面看到的状况是这样的：

def add_argument(self, *args, **kwargs):
    """
    add_argument(dest, ..., name=value, ...)
    add_argument(option_string, option_string, ..., name=value, ...)
    """

    # if no positional args are supplied or only one is supplied and
    # it doesn't look like an option string, parse a positional
    # argument

查阅以前的文档应该是这样：

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])
定义应该如何解析一个命令行参数。下面每一个参数有它们本身详细的描述，简单地讲它们是：

name or flags - 选项字符串的名字或者列表，例如foo 或者-f, --foo。
action - 在命令行遇到该参数时采起的基本动做类型。
nargs - 应该读取的命令行参数数目。
const - 某些action和nargs选项要求的常数值。
default - 若是命令行中没有出现该参数时的默认值。
type - 命令行参数应该被转换成的类型。
choices - 参数可容许的值的一个容器。
required - 该命令行选项是否能够省略（只针对可选参数）。
help - 参数的简短描述。
metavar - 参数在帮助信息中的名字。
dest - 给parse_args()返回的对象要添加的属性名称。

咱们按照之前的参数来介绍一下，由于我测试了一把用法上都没有改变。我目前的 python 版本是2.7.13。 add_argument 方法也被放进了父类 _ActionsContainer 中。

 

name or flags: 这个就是咱们能够直接写名字，若是直接写名字这就是一个必填参数，例子能够参考上面的例子。若是是 flags 就要带上 - 或者 -- 。这个 argparse 模块会帮咱们自动解析。

 

action: 这个参数算是一个重头戏并且能够继承 argparse.Action 定制本身的 action 。先介绍几个这个参数经常使用的变量：

• 'store' - 只是保存参数的值。这是默认的动做。例如：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo') >>> parser.parse_args('--foo 1'.split()) Namespace(foo='1') 

• 'store_const' - 保存由const关键字参数指出的值。（注意const关键字参数默认是几乎没有帮助的None。）'store_const'动做最经常使用于指定某种标记的可选参数。例如：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='store_const', const=42) >>> parser.parse_args('--foo'.split()) Namespace(foo=42)
  
  

  parser = argparse.ArgumentParser()
  aa=parser.add_argument('--foo', action='store_const', const=42)
  bb=parser.parse_args('--foo'.split())
  print(aa)
  print('----------------------------')
  print(bb)

  _StoreConstAction(option_strings=['--foo'], dest='foo', nargs=0, const=42, default=None, type=None, choices=None, help=None, metavar=None)
  ----------------------------
  Namespace(foo=42)

• 'store_true'和'store_false' - 它们是'store_const' 的特殊情形，分别用于保存值True和False。另外，它们分别会建立默认值False 和True。例如：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='store_true') >>> parser.add_argument('--bar', action='store_false') >>> parser.add_argument('--baz', action='store_false') >>> parser.parse_args('--foo --bar'.split()) Namespace(bar=False, baz=True, foo=True) 

• 'append' - 保存一个列表，并将每一个参数值附加在列表的后面。这对于容许指定屡次的选项颇有帮助。示例用法：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', action='append') >>> parser.parse_args('--foo 1 --foo 2'.split()) Namespace(foo=['1', '2']) 

• 'append_const' - 保存一个列表，并将const关键字参数指出的值附加在列表的后面。（注意const关键字参数默认是None。）'append_const' 动做在多个参数须要保存常量到相同的列表时特别有用。例如：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--str', dest='types', action='append_const', const=str) >>> parser.add_argument('--int', dest='types', action='append_const', const=int) >>> parser.parse_args('--str --int'.split()) Namespace(types=[<type 'str'>, <type 'int'>]) 

• 'count' - 计算关键字参数出现的次数。例如，这可用于增长详细的级别：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--verbose', '-v', action='count') >>> parser.parse_args('-vvv'.split()) Namespace(verbose=3) 

• 'help' - 打印当前解析器中全部选项的完整的帮助信息而后退出。默认状况下，help动做会自动添加到解析器中。参见ArgumentParser以获得如何生成输出信息。

• 'version' - 它期待version=参数出如今add_argument()调用中，在调用时打印出版本信息并退出：

  >>>

  >>> import argparse >>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0') >>> parser.parse_args(['--version']) PROG 2.0

以上所有摘自官方文档。

 

下面让我来尝试一把自定义 action 的实现。自定义 action 方法须要继承自 argparse.Action 类 而且实现一个 __call__ 方法。 __call__ 方法须要定义四个参数变量:

• parser - 包含该动做的ArgumentParser对象。
• namespace - parse_args()返回的Namespace对象。大部分动做会给该对象添加一个属性。
• values - 相关联的命令行参数于类型转换以后的值。（类型转换方式经过add_argument()的type关键字参数指定。）
• option_string - 调用该动做的选项字符串。option_string参数是可选的，若是动做关联的位置参数将不会出现。

 这里有个事例简单的易懂我直接上代码了：

>>> class FooAction(argparse.Action):
...     def __call__(self, parser, namespace, values, option_string=None):
...         print '%r %r %r' % (namespace, values, option_string)
...         setattr(namespace, self.dest, values)
...
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action=FooAction)
>>> parser.add_argument('bar', action=FooAction)
>>> args = parser.parse_args('1 --foo 2'.split())
Namespace(bar=None, foo=None) '1' None
Namespace(bar='1', foo=None) '2' '--foo'
>>> args
Namespace(bar='1', foo='2')

能够直接看到打印的那一行，当咱们在执行完 parse_args 的时候，执行到了 print '%r %r %r' % (namespace, values, option_string) 因此打印了出来。

能够看到 namespace 参数是一个 namespace 对象，values 就是给定的值， option_string  若是有可选参数就会加入进这个，若是没有则为 None。

 那么有人会问， 那 parser 这个参数呢，这个参数通过个人测试就是 .add_argument 以前的那个对象，如出一辙，会被传递进去。知道了这些，就能够基于这些知识对 action 这个方法作一些魔改了。这里就不展开了，根据需求定制便可。

 

nargs：这个入参能够设置一个 参数后面能够接收几个值，并且提供了相似于正则的符号来通配一些行为。

ArgumentParser对象一般将一个动做与一个命令行参数关联。nargs关键字参数将一个动做与不一样数目的命令行参数关联在一块儿。它支持的值有：

• N（一个整数）。命令行中的N个参数将被一块儿收集在一个列表中。例如：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', nargs=2) >>> parser.add_argument('bar', nargs=1) >>> parser.parse_args('c --foo a b'.split()) Namespace(bar=['c'], foo=['a', 'b']) 

  注意nargs=1生成一个只有一个元素的列表。这和默认的行为是不同的，默认状况下生成的是元素本身。

• '?'。若是有的话就从命令行读取一个参数并生成一个元素。若是没有对应的命令行参数，则产生一个来自default的值。注意，对于可选参数，有另一种状况 - 有选项字符串可是后面没有跟随命令行参数。在这种状况下，将生成一个来自const的值。用一些例子加以解释：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', nargs='?', const='c', default='d') >>> parser.add_argument('bar', nargs='?', default='d') >>> parser.parse_args('XX --foo YY'.split()) Namespace(bar='XX', foo='YY') >>> parser.parse_args('XX --foo'.split()) Namespace(bar='XX', foo='c') >>> parser.parse_args(''.split()) Namespace(bar='d', foo='d') 

  nargs='?'的一种更常见的用法是容许可选的输入和输出文件：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), ... default=sys.stdin) >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), ... default=sys.stdout) >>> parser.parse_args(['input.txt', 'output.txt']) Namespace(infile=<open file 'input.txt', mode 'r' at 0x...>,  outfile=<open file 'output.txt', mode 'w' at 0x...>) >>> parser.parse_args([]) Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>,  outfile=<open file '<stdout>', mode 'w' at 0x...>) 

• '*'。出现的全部命令行参数都被收集到一个列表中。注意，通常状况下具备多个带有nargs='*'的位置参数是不合理的，可是多个带有nargs='*'的可选参数是可能的。例如：

  >>>

  >>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', nargs='*') >>> parser.add_argument('--bar', nargs='*') >>> parser.add_argument('baz', nargs='*') >>> parser.parse_args('a b --foo x y --bar 1 2'.split()) Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y']) 

• '+'。和'*'同样，出现的全部命令行参数都被收集到一个列表中。除此以外，若是没有至少出现一个命令行参数将会产生一个错误信息。例如：

  >>>

  >>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('foo', nargs='+') >>> parser.parse_args('a b'.split()) Namespace(foo=['a', 'b']) >>> parser.parse_args(''.split()) usage: PROG [-h] foo [foo ...] PROG: error: too few arguments 

• argparse.REMAINDER.全部剩余的命令行参数都被收集到一个列表中。这一般用于命令行工具分发命令到其它命令行工具：

  >>>

  >>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('--foo') >>> parser.add_argument('command') >>> parser.add_argument('args', nargs=argparse.REMAINDER) >>> print parser.parse_args('--foo B cmd --arg1 XX ZZ'.split()) Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B') 

若是没有提供nargs关键字参数，读取的参数个数取决于action。一般这意味着将读取一个命令行参数并产生一个元素（不是一个列表）。

 

const: const 参数在某些特定的 action 上面已经介绍到了会被使用，还有就是 nargs 是 '?' 的时候会优先使用 const 里面的值。

 

default:  对于参数，default的值用于选项字符串没有出如今命令行中的时候。

 

type: 能够设置传入参数要求的类型。

 

choices: 能够设置填入的参数在 choices 指定的范围内。

 

require: 有此参数，若是传入的时候没有将报出一个错误。

 

help: 填写该参数背后的一些帮助信息。

 

metavar 和 dst 放在一块儿说吧：

当ArgumentParser生成帮助信息时，它须要以某种方式引用每个参数。 默认状况下，ArgumentParser对象使用dest的值做为每一个对象的“名字”。默认状况下，对于位置参数直接使用dest的值，对于可选参数则将dest的值变为大写。因此，位置参数dest='bar'将引用成bar。后面带有一个命令行参数的可选参数--foo将引用成FOO。一个例子：

>>>

>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo') >>> parser.add_argument('bar') >>> parser.parse_args('X --foo Y'.split()) Namespace(bar='X', foo='Y') >>> parser.print_help() usage: [-h] [--foo FOO] bar positional arguments:  bar optional arguments:  -h, --help show this help message and exit  --foo FOO 

能够用metavar指定另一个名字：

>>>

>>> parser = argparse.ArgumentParser() >>> parser.add_argument('--foo', metavar='YYY') >>> parser.add_argument('bar', metavar='XXX') >>> parser.parse_args('X --foo Y'.split()) Namespace(bar='X', foo='Y') >>> parser.print_help() usage: [-h] [--foo YYY] XXX positional arguments:  XXX optional arguments:  -h, --help show this help message and exit  --foo YYY 

注意metavar只会改变显示出来的名字 - parse_args() 对象中属性的名字仍然由dest的值决定。

nargs的不一样值可能致使metavar使用屡次。传递一个列表给metavar将给每一个参数指定一个不一样的显示名字：

>>>

>>> parser = argparse.ArgumentParser(prog='PROG') >>> parser.add_argument('-x', nargs=2) >>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz')) >>> parser.print_help() usage: PROG [-h] [-x X X] [--foo bar baz] optional arguments:  -h, --help show this help message and exit  -x X X  --foo bar baz

大部分ArgumentParser动做给parse_args()返回对象的某个属性添加某些值。该属性的名字由add_argument()的dest关键字参数决定。对于位置参数的动做，dest 一般做为第一个参数提供给add_argument()：

>>>

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

对于可选参数的动做，dest的动做一般从选项字符串推导出来。ArgumentParser生成的dest的值是将第一长的选项字符串前面的--字符串去掉。若是没有提供长选项字符串，dest的得到则是将第一个短选项字符串前面的-字符去掉。任何内部的-将被转换为_字符以确保字符串是合法的属性名字。下面的实例解释了这个行为：

>>>

>>> 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') 

dest容许提供自定义的属性名：

>>>

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

 

 

若是咱们不想输入某些参数怎么办呀？

简单！直接在他们名字前添加--就好啦~ 咱们对刚刚的程序作个小修改

import argparse
parser = argparse.ArgumentParser()
parser.description='喂我两个数字，我就吐出他们的积' parser.add_argument("--ParA", help="我是A",type=int) parser.add_argument("--ParB", help="我是B",type=int) args = parser.parse_args() if args.ParA: print("我只吃到了A，它是",args.ParA) if args.ParB: print("我只吃到了B，它是",args.ParB) if args.ParA and args.ParB: print("啊，两个都吃到啦！积是",args.ParA*args.ParB) 

不过此次因为有些参数不肯定是否输入，因此在输入参数的时候咱们须要告诉程序咱们想要对哪一个参数赋值~

 

 

每次都要输入或者好累啊有木有.... 好懒的 T^T，因此咱们再作些修改吧，尽量的偷个懒=-=

import argparse
parser = argparse.ArgumentParser()
parser.description='喂我两个数字，我就吐出他们的积' parser.add_argument("-a","--ParA", help="我是A",type=int) parser.add_argument("-b","--ParB", help="我是B",type=int) args = parser.parse_args() if args.ParA: print("我只吃到了A，它是",args.ParA) if args.ParB: print("我只吃到了B，它是",args.ParB) if args.ParA and args.ParB: print("啊，两个都吃到啦！积是",args.ParA*args.ParB) 

如今，咱们就能够用或者输入参数啦~彷佛也没有轻松多少....都是骗人的T^T

 

连接：https://www.jianshu.com/p/00425f6c0936

 

Reference:

https://www.jianshu.com/p/fef2d215b91d  python argparse用法总结

http://python.usyiyi.cn/translate/python_278/library/argparse.html  argparse官方文档翻译

 

经过Python的argparse模块解析命令行选项

目录

做者：杨冬 欢迎转载，也请保留这段声明。谢谢！
出处：https://andyyoung01.github.io/ 或 http://andyyoung01.16mb.com/

若是想要经过Python写出一个基于命令行的程序，若是程序的命令行参数较多，可使用Python内置的argparse模块来处理命令行参数。

能够经过一个实例程序来探索argparse的用法：

search.py

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

import argparse   parser = argparse.ArgumentParser(description= 'Search some files')   parser.add_argument(dest= 'filenames',metavar='filename', nargs='*')   parser.add_argument( '-p', '--pat',metavar='pattern', required=True, dest= 'patterns', action='append', help= 'text pattern to search for')   parser.add_argument( '-v', dest='verbose', action='store_true', help= 'verbose mode')   parser.add_argument( '-o', dest='outfile', action='store', help= 'output file')   parser.add_argument( '--speed', dest='speed', action='store', choices={ 'slow','fast'}, default='slow', help= 'search speed')   args = parser.parse_args()   # Output the collected arguments print(args.filenames) print(args.patterns) print(args.verbose) print(args.outfile) print(args.speed)

 

#python3 argtest.py -p a -v 4 -o /mcw/abc/ --speed fast
Namespace(filenames=['4'], outfile='/mcw/abc/', patterns=['a'], speed='fast', verbose=True)
['4']
['a']
True
/mcw/abc/
fast

 

能够经过以下的方式使用上面定义的脚本文件：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

[yangdong@centos7 ~]$ python3 search.py -h usage: search.py [-h] [-p pattern] [-v] [-o OUTFILE] [--speed {slow,fast}] [filename [filename ...]]   Search some files   positional arguments: filename   optional arguments: -h, --help show this help message and exit -p pattern, --pat pattern text pattern to search for -v verbose mode -o OUTFILE output file --speed {slow,fast} search speed   [yangdong@centos7 ~]$ python3 search.py foo.txt bar.txt usage: search.py [-h] -p pattern [-v] [-o OUTFILE] [--speed {fast,slow}] [filename [filename ...]] search.py: error: the following arguments are required: -p/--pat   [yangdong@centos7 ~]$ python3 search.py -v -p spam --pat=eggs foo.txt bar.txt filenames = ['foo.txt', 'bar.txt'] patterns = ['spam', 'eggs'] verbose = True outfile = None speed = slow   [yangdong@centos7 ~]$ python3 search.py -v -p spam --pat=eggs foo.txt bar.txt -o results filenames = ['foo.txt', 'bar.txt'] patterns = ['spam', 'eggs'] verbose = True outfile = results speed = slow   [yangdong@centos7 ~]$ python3 search.py -v -p spam --pat=eggs foo.txt bar.txt -o results \ --speed=fast filenames = ['foo.txt', 'bar.txt'] patterns = ['spam', 'eggs'] verbose = True outfile = results speed = fast   Namespace(filenames=['foo.txt', 'bar.txt'], outfile='results', patterns=['spam', 'eggs'], speed='fast', verbose=True) 点键取值。有choices的就是能够=赋值  。键是dest目标

 

为了解析命令行选项，你首先要建立一个ArgumentParser实例， 并使用add_argument()方法声明你想要支持的选项。 在每一个add_argument()调用中，dest参数指定将解析结果存入以该参数命名的属性中。metavar参数被用来生成帮助信息。action参数指定跟属性对应的处理逻辑，一般的值为store ,被用来存储某个值或将多个参数值收集到一个列表中。 更详细的add_argument()的参数解释请参考官网（或中文翻译）。
在设置完参数后，即可以执行parser.parse()方法了。它会处理sys.argv的值并返回一个结果实例。每一个参数值都会被设置成该实例中add_argument()方法的dest参数指定的属性值。

还不少种其余方法解析命令行选项。 例如，你可能会手动的处理 sys.argv 或者使用 getopt 模块。 可是，若是你采用本节的方式，将会减小不少冗余代码，底层细节 argparse 模块已经帮你处理了。 你可能还会碰到使用 optparse 库解析选项的代码。 尽管 optparse 和 argparse 很像，可是后者更先进，所以在新的程序中你应该使用它。