Park Lam's 每日分享

Python使用工具：docopt-ng库使用教程

作者：

Park Lam

在

1. Python在现代技术生态中的核心地位

Python作为一种高级、解释型的编程语言，凭借其简洁的语法和强大的功能，已经成为当今技术领域中应用最为广泛的编程语言之一。从Web开发到数据分析，从人工智能到自动化脚本，Python的身影无处不在。在Web开发领域，Django和Flask等框架为开发者提供了高效构建Web应用的工具；在数据分析和数据科学领域，NumPy、Pandas和Matplotlib等库使得数据处理和可视化变得轻而易举；在机器学习和人工智能领域，TensorFlow、PyTorch和Scikit-learn等库推动了该领域的快速发展；在桌面自动化和爬虫脚本方面，Selenium和BeautifulSoup等库让自动化任务和数据采集变得简单高效；在金融和量化交易领域，Python也被广泛应用于算法交易和风险分析等方面；在教育和研究领域，Python因其易学易用的特点，成为了许多学生和研究人员的首选编程语言。

Python的成功得益于其丰富的库和工具生态系统。这些库和工具为开发者提供了各种各样的功能，使得他们可以更加高效地完成各种任务。本文将介绍一个在命令行参数解析领域非常实用的Python库——docopt-ng。

2. docopt-ng库概述

2.1 用途

docopt-ng是一个基于文档字符串（docstring）来解析命令行参数的Python库。它的主要用途是让命令行界面（CLI）的开发变得更加简单和直观。通过使用docopt-ng，开发者只需要编写清晰、规范的文档字符串，就可以自动生成命令行参数解析器，而不需要编写大量的样板代码。

2.2 工作原理

docopt-ng的工作原理非常简单：它会读取程序的文档字符串，并根据其中的格式规范来解析命令行参数。文档字符串中需要包含程序的使用帮助信息，包括命令行参数的格式、选项和参数的描述等。docopt-ng会分析这些信息，并生成一个解析器，用于解析用户输入的命令行参数。

2.3 优缺点

优点：

  • 简洁高效：只需要编写文档字符串，不需要编写额外的参数解析代码，大大减少了开发工作量。
  • 文档即规范：文档字符串既是程序的使用帮助，也是参数解析的规范，保证了文档与代码的一致性。
  • 易于学习和使用：docopt-ng的语法简单直观，容易上手。
  • 跨平台兼容：可以在不同的操作系统上使用，保证了程序的可移植性。

缺点：

  • 灵活性有限：对于非常复杂的命令行参数解析需求，可能无法满足。
  • 错误处理不够友好：当用户输入的参数不符合文档字符串中的规范时，错误信息可能不够直观。

2.4 License类型

docopt-ng采用MIT License，这是一种非常宽松的开源许可证，允许用户自由使用、修改和分发该库。

3. docopt-ng库的详细使用方式

3.1 安装docopt-ng

使用pip可以很方便地安装docopt-ng：

pip install docopt-ng

3.2 基本用法

docopt-ng的基本用法非常简单，只需要按照以下步骤操作：

  1. 编写文档字符串，描述程序的使用方法和参数。
  2. 在程序中导入docopt函数，并调用它来解析命令行参数。
  3. 使用解析后的参数进行相应的操作。

下面是一个简单的示例：

"""
Usage:
  hello.py [--name=<name>]
  hello.py (-h | --help)

Options:
  -h --help         Show this screen.
  --name=<name>     Your name [default: World].
"""

from docopt import docopt

def main():
    arguments = docopt(__doc__, version='Hello World 1.0')
    print(f"Hello, {arguments['--name']}!")

if __name__ == '__main__':
    main()

在这个示例中，我们定义了一个简单的程序，它接受一个可选的--name参数，用于指定要问候的对象。文档字符串中使用了特定的格式来描述程序的用法和参数：

  • Usage:部分描述了程序的基本用法，包括命令和参数的格式。
  • Options:部分描述了可用的选项，包括选项的短名称、长名称、描述和默认值。

docopt函数会解析命令行参数，并返回一个字典，其中包含了用户输入的参数和选项的值。在这个示例中，我们通过arguments['--name']来获取用户指定的名称。

3.3 位置参数

位置参数是指在命令行中按照特定顺序出现的参数。下面是一个使用位置参数的示例：

"""
Usage:
  add.py <num1> <num2>
  add.py (-h | --help)

Options:
  -h --help         Show this screen.
"""

from docopt import docopt

def main():
    arguments = docopt(__doc__)
    num1 = float(arguments['<num1>'])
    num2 = float(arguments['<num2>'])
    result = num1 + num2
    print(f"{num1} + {num2} = {result}")

if __name__ == '__main__':
    main()

在这个示例中，<num1>和<num2>是两个位置参数，用户需要按照顺序在命令行中提供这两个参数的值。docopt函数会将这两个参数的值解析到返回的字典中，我们可以通过arguments['<num1>']和arguments['<num2>']来获取它们。

3.4 选项参数

选项参数是指以-或--开头的参数，用于控制程序的行为。选项参数可以分为带值选项和不带值选项。

下面是一个使用带值选项的示例：

"""
Usage:
  file_size.py [--unit=&lt;unit>] &lt;filename>
  file_size.py (-h | --help)

Options:
  -h --help             Show this screen.
  --unit=&lt;unit>         Unit of measurement: b, kb, mb, gb [default: b].
"""

from docopt import docopt
import os

def main():
    arguments = docopt(__doc__)
    filename = arguments['&lt;filename>']
    unit = arguments['--unit']

    if not os.path.exists(filename):
        print(f"Error: File '{filename}' does not exist.")
        return

    size = os.path.getsize(filename)

    if unit == 'kb':
        size /= 1024
    elif unit == 'mb':
        size /= (1024 * 1024)
    elif unit == 'gb':
        size /= (1024 * 1024 * 1024)

    print(f"File size: {size:.2f} {unit}")

if __name__ == '__main__':
    main()

在这个示例中，--unit是一个带值选项，用于指定文件大小的单位。用户可以通过--unit=kb、--unit=mb或--unit=gb来指定不同的单位，默认单位是字节（b）。

下面是一个使用不带值选项的示例：

"""
Usage:
  text_processor.py [--upper | --lower] &lt;text>
  text_processor.py (-h | --help)

Options:
  -h --help         Show this screen.
  --upper           Convert text to uppercase.
  --lower           Convert text to lowercase.
"""

from docopt import docopt

def main():
    arguments = docopt(__doc__)
    text = arguments['&lt;text>']

    if arguments['--upper']:
        print(text.upper())
    elif arguments['--lower']:
        print(text.lower())
    else:
        print(text)

if __name__ == '__main__':
    main()

在这个示例中，--upper和--lower是两个不带值选项，用于控制文本的大小写转换。用户可以选择其中一个选项，如果不选择任何选项，则文本保持原样。

3.5 子命令

子命令是指在主命令后面跟随的命令，用于执行不同的操作。docopt-ng支持子命令的定义和解析。

下面是一个使用子命令的示例：

"""
Usage:
  myapp.py add &lt;num1> &lt;num2>
  myapp.py subtract &lt;num1> &lt;num2>
  myapp.py multiply &lt;num1> &lt;num2>
  myapp.py divide &lt;num1> &lt;num2>
  myapp.py (-h | --help)

Options:
  -h --help         Show this screen.
"""

from docopt import docopt

def main():
    arguments = docopt(__doc__)

    num1 = float(arguments['&lt;num1>'])
    num2 = float(arguments['&lt;num2>'])

    if arguments['add']:
        result = num1 + num2
        print(f"{num1} + {num2} = {result}")
    elif arguments['subtract']:
        result = num1 - num2
        print(f"{num1} - {num2} = {result}")
    elif arguments['multiply']:
        result = num1 * num2
        print(f"{num1} * {num2} = {result}")
    elif arguments['divide']:
        if num2 == 0:
            print("Error: Division by zero.")
        else:
            result = num1 / num2
            print(f"{num1} / {num2} = {result}")

if __name__ == '__main__':
    main()

在这个示例中，我们定义了四个子命令：add、subtract、multiply和divide，每个子命令都接受两个数字作为参数，并执行相应的运算。docopt函数会解析用户输入的子命令，并将其对应的布尔值设置为True，我们可以通过检查这些布尔值来确定用户执行的是哪个子命令。

3.6 复杂示例

下面是一个更复杂的示例，展示了docopt-ng的更多功能：

"""
Usage:
  mytool.py [options] [--] &lt;input>...
  mytool.py (-h | --help | --version)

Options:
  -h --help                 Show this screen.
  --version                 Show version.
  -o FILE, --output=FILE    Output file [default: output.txt].
  -v, --verbose             Increase verbosity.
  -q, --quiet               Decrease verbosity.
  --encoding=ENCODING       Encoding for input/output [default: utf-8].
  --filter=FILTER           Filter results by FILTER.
  --limit=LIMIT             Limit the number of results [default: 10].
  --format=FORMAT           Output format: json, csv, text [default: text].

Examples:
  mytool.py file1.txt file2.txt
  mytool.py -v --format=json --limit=5 data/*.txt -o results.json
  mytool.py --filter="error" logs/*.log
"""

from docopt import docopt
import sys
import os
import json
import csv

def main():
    arguments = docopt(__doc__, version='MyTool 1.0')

    # 获取输入文件列表
    input_files = arguments['&lt;input>']

    # 获取选项值
    output_file = arguments['--output']
    verbose = arguments['--verbose']
    quiet = arguments['--quiet']
    encoding = arguments['--encoding']
    filter_text = arguments['--filter']
    limit = int(arguments['--limit'])
    format = arguments['--format']

    # 检查输入文件是否存在
    for filename in input_files:
        if not os.path.exists(filename):
            print(f"Error: File '{filename}' does not exist.", file=sys.stderr)
            sys.exit(1)

    # 处理输入文件
    results = []
    for filename in input_files:
        if verbose:
            print(f"Processing file: {filename}")

        try:
            with open(filename, 'r', encoding=encoding) as f:
                lines = f.readlines()

                # 应用过滤
                if filter_text:
                    lines = [line for line in lines if filter_text in line]

                # 应用限制
                if limit > 0:
                    lines = lines[:limit]

                results.extend([{
                    'filename': filename,
                    'line_number': i + 1,
                    'content': line.strip()
                } for i, line in enumerate(lines)])

        except Exception as e:
            print(f"Error reading file '{filename}': {str(e)}", file=sys.stderr)
            if not quiet:
                sys.exit(1)

    # 输出结果
    if format == 'json':
        with open(output_file, 'w', encoding=encoding) as f:
            json.dump(results, f, indent=2)
        if verbose:
            print(f"Results saved to {output_file} in JSON format.")

    elif format == 'csv':
        with open(output_file, 'w', encoding=encoding, newline='') as f:
            writer = csv.DictWriter(f, fieldnames=['filename', 'line_number', 'content'])
            writer.writeheader()
            writer.writerows(results)
        if verbose:
            print(f"Results saved to {output_file} in CSV format.")

    else:  # text format
        with open(output_file, 'w', encoding=encoding) as f:
            for result in results:
                f.write(f"{result['filename']}:{result['line_number']} {result['content']}\n")
        if verbose:
            print(f"Results saved to {output_file} in text format.")

if __name__ == '__main__':
    main()

这个示例展示了docopt-ng的多种功能，包括位置参数、选项参数、默认值、类型转换、文件处理等。程序可以处理多个输入文件，支持过滤、限制结果数量，并可以将结果以不同的格式输出到文件中。

4. 实际案例：文件搜索工具

下面我们通过一个实际案例来展示docopt-ng的应用。我们将创建一个简单的文件搜索工具，用于在指定目录中搜索包含特定文本的文件。

"""
文件搜索工具

Usage:
  file_search.py [options] &lt;search_text> &lt;directory>
  file_search.py (-h | --help | --version)

Options:
  -h --help                 Show this screen.
  --version                 Show version.
  -r, --recursive           Search recursively in subdirectories.
  -i, --ignore-case         Ignore case when searching.
  -e EXT, --extension=EXT   Only search files with the given extension (e.g., .txt, .py).
  -n, --no-filename         Do not show filenames in results.
  -m MAX, --max-results=MAX  Maximum number of results to show [default: 100].
  --encoding=ENCODING       Encoding to use when reading files [default: utf-8].
"""

from docopt import docopt
import os
import re

def main():
    arguments = docopt(__doc__, version='文件搜索工具 1.0')

    search_text = arguments['&lt;search_text>']
    directory = arguments['&lt;directory>']
    recursive = arguments['--recursive']
    ignore_case = arguments['--ignore-case']
    extension = arguments['--extension']
    no_filename = arguments['--no-filename']
    max_results = int(arguments['--max-results'])
    encoding = arguments['--encoding']

    # 检查目录是否存在
    if not os.path.isdir(directory):
        print(f"错误: 目录 '{directory}' 不存在。")
        return

    # 编译正则表达式
    flags = re.IGNORECASE if ignore_case else 0
    pattern = re.compile(re.escape(search_text), flags)

    # 搜索文件
    results = []
    count = 0

    for root, dirs, files in os.walk(directory):
        for filename in files:
            # 检查文件扩展名
            if extension and not filename.endswith(extension):
                continue

            file_path = os.path.join(root, filename)

            # 读取文件内容并搜索
            try:
                with open(file_path, 'r', encoding=encoding) as f:
                    for line_num, line in enumerate(f, 1):
                        if pattern.search(line):
                            if no_filename:
                                results.append((None, line_num, line.strip()))
                            else:
                                results.append((file_path, line_num, line.strip()))
                            count += 1

                            if count >= max_results:
                                break

                if count >= max_results:
                    break

            except (UnicodeDecodeError, PermissionError) as e:
                # 忽略无法读取的文件
                continue

        if count >= max_results:
            break

        # 如果不递归搜索，则跳过子目录
        if not recursive:
            break

    # 显示结果
    if results:
        print(f"找到 {len(results)} 个匹配项:")
        for file_path, line_num, content in results:
            if file_path:
                print(f"{file_path}:{line_num}: {content}")
            else:
                print(f"{line_num}: {content}")
    else:
        print("未找到匹配项。")

if __name__ == '__main__':
    main()

这个文件搜索工具具有以下功能：

  • 可以在指定目录中搜索包含特定文本的文件
  • 支持递归搜索子目录
  • 支持忽略大小写
  • 可以指定搜索特定扩展名的文件
  • 可以限制显示的结果数量
  • 可以选择不显示文件名

使用docopt-ng，我们只需要编写清晰的文档字符串，就可以实现一个功能完整的命令行工具，而不需要编写复杂的参数解析代码。

5. 相关资源

  • Pypi地址：https://pypi.org/project/docopt-ng/
  • Github地址：https://github.com/docopt/docopt-ng
  • 官方文档地址：https://docopt.github.io/docopt-ng/

关注我，每天分享一个实用的Python自动化工具。

更多文章