Tôi đang sử dụng argparsetrong Python 2.7 để phân tích các tùy chọn nhập liệu. Một trong những lựa chọn của tôi là nhiều lựa chọn. Tôi muốn tạo một danh sách trong văn bản trợ giúp của nó, vd

from argparse import ArgumentParser

parser = ArgumentParser(description='test')

parser.add_argument('-g', choices=['a', 'b', 'g', 'd', 'e'], default='a',
    help="Some option, where\n"
         " a = alpha\n"
         " b = beta\n"
         " g = gamma\n"
         " d = delta\n"
         " e = epsilon")

parser.parse_args()

Tuy nhiên, argparsedải tất cả các dòng mới và không gian liên tiếp. Kết quả trông như

~ / Tải xuống: 52 $ python2.7 x.py -h
cách sử dụng: x.py [-h] [-g {a, b, g, d, e}]

kiểm tra

đối số tùy chọn:
  -h, --hỗ trợ hiển thị thông báo trợ giúp này và thoát
  -g {a, b, g, d, e} Một số tùy chọn, trong đó a = alpha b = beta g = gamma d = delta e
                  = epsilon

Làm thế nào để chèn dòng mới trong văn bản trợ giúp?

Hãy thử sử dụng RawTextHelpFormatter:

from argparse import RawTextHelpFormatter
parser = ArgumentParser(description='test', formatter_class=RawTextHelpFormatter)

Nếu bạn chỉ muốn ghi đè một tùy chọn, bạn không nên sử dụng RawTextHelpFormatter. Thay vào đó, phân lớp HelpFormattervà cung cấp phần giới thiệu đặc biệt cho các tùy chọn nên được xử lý "thô" (tôi sử dụng "R|rest of help"):

import argparse

class SmartFormatter(argparse.HelpFormatter):

    def _split_lines(self, text, width):
        if text.startswith('R|'):
            return text[2:].splitlines()  
        # this is the RawTextHelpFormatter._split_lines
        return argparse.HelpFormatter._split_lines(self, text, width)

Và sử dụng nó:

from argparse import ArgumentParser

parser = ArgumentParser(description='test', formatter_class=SmartFormatter)

parser.add_argument('-g', choices=['a', 'b', 'g', 'd', 'e'], default='a',
    help="R|Some option, where\n"
         " a = alpha\n"
         " b = beta\n"
         " g = gamma\n"
         " d = delta\n"
         " e = epsilon")

parser.parse_args()

Bất kỳ cuộc gọi nào khác .add_argument()mà sự trợ giúp không bắt đầu R|sẽ được kết thúc như bình thường.

Đây là một phần trong những cải tiến của tôi trên argparse . SmartFormatter đầy đủ cũng hỗ trợ thêm mặc định cho tất cả các tùy chọn và nhập liệu thô của mô tả tiện ích. Phiên bản đầy đủ có _split_linesphương thức riêng của nó , do đó mọi định dạng được thực hiện đối với các chuỗi phiên bản được giữ nguyên:

parser.add_argument('--version', '-v', action="version",
                    version="version...\n   42!")

Một cách dễ dàng khác để làm điều đó là bao gồm textwrap .

Ví dụ,

import argparse, textwrap
parser = argparse.ArgumentParser(description='some information',
        usage='use "python %(prog)s --help" for more information',
        formatter_class=argparse.RawTextHelpFormatter)

parser.add_argument('--argument', default=somedefault, type=sometype,
        help= textwrap.dedent('''\
        First line
        Second line
        More lines ... '''))

Bằng cách này, chúng ta có thể tránh khoảng trống dài phía trước mỗi dòng đầu ra.

usage: use "python your_python_program.py --help" for more information

Prepare input file

optional arguments:
-h, --help            show this help message and exit
--argument ARGUMENT
                      First line
                      Second line
                      More lines ...

Tôi đã phải đối mặt với vấn đề tương tự (Python 2.7.6). Tôi đã cố chia phần mô tả thành nhiều dòng bằng cách sử dụng RawTextHelpFormatter:

parser = ArgumentParser(description="""First paragraph 

                                       Second paragraph

                                       Third paragraph""",  
                                       usage='%(prog)s [OPTIONS]', 
                                       formatter_class=RawTextHelpFormatter)

options = parser.parse_args()

Và có:

cách sử dụng: play-with-argparse.py [TÙY CHỌN]

Đoạn đầu 

                        Đoạn thứ hai

                        Đoạn thứ ba

đối số tùy chọn:
  -h, --hỗ trợ hiển thị thông báo trợ giúp này và thoát

Vì vậy, RawTextHelpFormatterkhông phải là một giải pháp. Bởi vì nó in mô tả như xuất hiện trong mã nguồn, bảo toàn tất cả các ký tự khoảng trắng (tôi muốn giữ các tab bổ sung trong mã nguồn của mình để dễ đọc nhưng tôi không muốn in tất cả chúng. quá dài, hơn 80 ký tự chẳng hạn).

Cảm ơn @Anton, người đã truyền cảm hứng cho hướng đi đúng đắn ở trên . Nhưng giải pháp đó cần sửa đổi một chút để định dạng phần mô tả .

Dù sao, định dạng tùy chỉnh là cần thiết. Tôi đã mở rộng HelpFormatterlớp hiện có và _fill_textphương thức overrode như thế này:

import textwrap as _textwrap
class MultilineFormatter(argparse.HelpFormatter):
    def _fill_text(self, text, width, indent):
        text = self._whitespace_matcher.sub(' ', text).strip()
        paragraphs = text.split('|n ')
        multiline_text = ''
        for paragraph in paragraphs:
            formatted_paragraph = _textwrap.fill(paragraph, width, initial_indent=indent, subsequent_indent=indent) + '\n\n'
            multiline_text = multiline_text + formatted_paragraph
        return multiline_text

So sánh với mã nguồn ban đầu đến từ mô-đun argparse :

def _fill_text(self, text, width, indent):
    text = self._whitespace_matcher.sub(' ', text).strip()
    return _textwrap.fill(text, width, initial_indent=indent,
                                       subsequent_indent=indent)

Trong mã gốc, toàn bộ mô tả đang được bọc. Trong định dạng tùy chỉnh ở trên, toàn bộ văn bản được chia thành nhiều phần và mỗi phần được định dạng độc lập.

Vì vậy, với sự trợ giúp của định dạng tùy chỉnh:

parser = ArgumentParser(description= """First paragraph 
                                        |n                              
                                        Second paragraph
                                        |n
                                        Third paragraph""",  
                usage='%(prog)s [OPTIONS]',
                formatter_class=MultilineFormatter)

options = parser.parse_args()

đầu ra là:

cách sử dụng: play-with-argparse.py [TÙY CHỌN]

Đoạn đầu

Đoạn thứ hai

Đoạn thứ ba

đối số tùy chọn:
  -h, --hỗ trợ hiển thị thông báo trợ giúp này và thoát

Tôi muốn có cả ngắt dòng thủ công trong văn bản mô tả và tự động gói nó; nhưng không có gợi ý nào ở đây có hiệu quả với tôi - vì vậy cuối cùng tôi đã sửa đổi lớp SmartFormatter được đưa ra trong các câu trả lời ở đây; các vấn đề với tên phương thức argparse không phải là API công khai, đây là những gì tôi có (dưới dạng tệp được gọi test.py):

import argparse
from argparse import RawDescriptionHelpFormatter

# call with: python test.py -h

class SmartDescriptionFormatter(argparse.RawDescriptionHelpFormatter):
  #def _split_lines(self, text, width): # RawTextHelpFormatter, although function name might change depending on Python
  def _fill_text(self, text, width, indent): # RawDescriptionHelpFormatter, although function name might change depending on Python
    #print("splot",text)
    if text.startswith('R|'):
      paragraphs = text[2:].splitlines()
      rebroken = [argparse._textwrap.wrap(tpar, width) for tpar in paragraphs]
      #print(rebroken)
      rebrokenstr = []
      for tlinearr in rebroken:
        if (len(tlinearr) == 0):
          rebrokenstr.append("")
        else:
          for tlinepiece in tlinearr:
            rebrokenstr.append(tlinepiece)
      #print(rebrokenstr)
      return '\n'.join(rebrokenstr) #(argparse._textwrap.wrap(text[2:], width))
    # this is the RawTextHelpFormatter._split_lines
    #return argparse.HelpFormatter._split_lines(self, text, width)
    return argparse.RawDescriptionHelpFormatter._fill_text(self, text, width, indent)

parser = argparse.ArgumentParser(formatter_class=SmartDescriptionFormatter, description="""R|Blahbla bla blah blahh/blahbla (bla blah-blabla) a blahblah bl a blaha-blah .blah blah

Blah blah bla blahblah, bla blahblah blah blah bl blblah bl blahb; blah bl blah bl bl a blah, bla blahb bl:

  blah blahblah blah bl blah blahblah""")

options = parser.parse_args()

Đây là cách nó hoạt động trong 2.7 và 3.4:

$ python test.py -h
usage: test.py [-h]

Blahbla bla blah blahh/blahbla (bla blah-blabla) a blahblah bl a blaha-blah
.blah blah

Blah blah bla blahblah, bla blahblah blah blah bl blblah bl blahb; blah bl
blah bl bl a blah, bla blahb bl:

  blah blahblah blah bl blah blahblah

optional arguments:
  -h, --help  show this help message and exit

Bắt đầu từ SmartFomatter được mô tả ở trên, tôi đã kết thúc giải pháp đó:

class SmartFormatter(argparse.HelpFormatter):
    '''
         Custom Help Formatter used to split help text when '\n' was 
         inserted in it.
    '''

    def _split_lines(self, text, width):
        r = []
        for t in text.splitlines(): r.extend(argparse.HelpFormatter._split_lines(self, t, width))
        return r

Lưu ý rằng kỳ lạ là đối số formatter_group được truyền cho trình phân tích cú pháp cấp cao nhất không được kế thừa bởi sub_parsers, người ta phải truyền lại nó cho mỗi sub_parser được tạo.

Lời nói đầu

Đối với câu hỏi này, argparse.RawTextHelpFormatterlà hữu ích cho tôi.

Bây giờ, tôi muốn chia sẻ làm thế nào để tôi sử dụng argparse.

Tôi biết nó có thể không liên quan đến câu hỏi,

nhưng những câu hỏi này đã làm phiền tôi trong một thời gian.

Vì vậy, tôi muốn chia sẻ kinh nghiệm của mình, hy vọng điều đó sẽ hữu ích cho ai đó.

Chúng ta đi đây.

Mô-đun bên thứ 3

colorama : để thay đổi màu văn bản:pip install colorama

Làm cho chuỗi ký tự thoát ANSI (để tạo văn bản đầu cuối màu và định vị con trỏ) hoạt động trong MS Windows

Thí dụ

import colorama
from colorama import Fore, Back
from pathlib import Path
from os import startfile, system

SCRIPT_DIR = Path(__file__).resolve().parent
TEMPLATE_DIR = SCRIPT_DIR.joinpath('.')


def main(args):
    ...


if __name__ == '__main__':
    colorama.init(autoreset=True)

    from argparse import ArgumentParser, RawTextHelpFormatter

    format_text = FormatText([(20, '<'), (60, '<')])
    yellow_dc = format_text.new_dc(fore_color=Fore.YELLOW)
    green_dc = format_text.new_dc(fore_color=Fore.GREEN)
    red_dc = format_text.new_dc(fore_color=Fore.RED, back_color=Back.LIGHTYELLOW_EX)

    script_description = \
        '\n'.join([desc for desc in
                   [f'\n{green_dc(f"python {Path(__file__).name} [REFERENCE TEMPLATE] [OUTPUT FILE NAME]")} to create template.',
                    f'{green_dc(f"python {Path(__file__).name} -l *")} to get all available template',
                    f'{green_dc(f"python {Path(__file__).name} -o open")} open template directory so that you can put your template file there.',
                    # <- add your own description
                    ]])
    arg_parser = ArgumentParser(description=yellow_dc('CREATE TEMPLATE TOOL'),
                                # conflict_handler='resolve',
                                usage=script_description, formatter_class=RawTextHelpFormatter)

    arg_parser.add_argument("ref", help="reference template", nargs='?')
    arg_parser.add_argument("outfile", help="output file name", nargs='?')
    arg_parser.add_argument("action_number", help="action number", nargs='?', type=int)
    arg_parser.add_argument('--list', "-l", dest='list',
                            help=f"example: {green_dc('-l *')} \n"
                                 "description: list current available template. (accept regex)")

    arg_parser.add_argument('--option', "-o", dest='option',
                            help='\n'.join([format_text(msg_data_list) for msg_data_list in [
                                ['example', 'description'],
                                [green_dc('-o open'), 'open template directory so that you can put your template file there.'],
                                [green_dc('-o run'), '...'],
                                [green_dc('-o ...'), '...'],
                                # <- add your own description
                            ]]))

    g_args = arg_parser.parse_args()
    task_run_list = [[False, lambda: startfile('.')] if g_args.option == 'open' else None,
                     [False, lambda: [print(template_file_path.stem) for template_file_path in TEMPLATE_DIR.glob(f'{g_args.list}.py')]] if g_args.list else None,
                     # <- add your own function
                     ]
    for leave_flag, func in [task_list for task_list in task_run_list if task_list]:
        func()
        if leave_flag:
            exit(0)

    # CHECK POSITIONAL ARGUMENTS
    for attr_name, value in vars(g_args).items():
        if attr_name.startswith('-') or value is not None:
            continue
        system('cls')
        print(f'error required values of {red_dc(attr_name)} is None')
        print(f"if you need help, please use help command to help you: {red_dc(f'python {__file__} -h')}")
        exit(-1)
    main(g_args)

Trường hợp của lớp FormatTextlà sau

class FormatText:
    __slots__ = ['align_list']

    def __init__(self, align_list: list, autoreset=True):
        """
        USAGE::

            format_text = FormatText([(20, '<'), (60, '<')])
            red_dc = format_text.new_dc(fore_color=Fore.RED)
            print(red_dc(['column 1', 'column 2']))
            print(red_dc('good morning'))
        :param align_list:
        :param autoreset:
        """
        self.align_list = align_list
        colorama.init(autoreset=autoreset)

    def __call__(self, text_list: list):
        if len(text_list) != len(self.align_list):
            if isinstance(text_list, str):
                return text_list
            raise AttributeError
        return ' '.join(f'{txt:{flag}{int_align}}' for txt, (int_align, flag) in zip(text_list, self.align_list))

    def new_dc(self, fore_color: Fore = Fore.GREEN, back_color: Back = ""):  # DECORATOR
        """create a device context"""
        def wrap(msgs):
            return back_color + fore_color + self(msgs) + Fore.RESET
        return wrap