У меня есть редактор python, в котором пользователь вводит скрипт или код, который затем помещается в основной метод за кулисами, при этом каждая строка имеет отступ. Проблема в том, что если у пользователя есть многострочная строка, отступ, сделанный для всего скрипта, влияет на строку, вставляя табуляцию в каждый пробел. Проблемный сценарий был бы таким простым, как:

 """foo
bar
foo2"""
 

Итак, когда в основном методе это будет выглядеть так:

 def main():
    """foo
    bar
    foo2"""
 

и теперь строка будет иметь дополнительную вкладку в начале каждой строки.

textwrap.dedent из стандартной библиотеки предназначен для автоматической отмены дурацкого отступа.

Из того, что я вижу, лучшим ответом здесь может быть inspect.cleandoc , который делает многое из того, что textwrap.dedent делает, но также устраняет проблемы, textwrap.dedent связанные с начальной строкой.

Приведенный ниже пример показывает различия:

 >>> import textwrap
>>> import inspect
>>> x = """foo bar
    baz
    foobar
    foobaz
    """
>>> inspect.cleandoc(x)
'foo barnbaznfoobarnfoobaz'
>>> textwrap.dedent(x)
'foo barn    bazn    foobarn    foobazn'
>>> y = """
...     foo
...     bar
... """
>>> inspect.cleandoc(y)
'foonbar'
>>> textwrap.dedent(y)
'nfoonbarn'
>>> z = """tfoo
bartbaz
"""
>>> inspect.cleandoc(z)
'foonbar     baz'
>>> textwrap.dedent(z)
'tfoonbartbazn'

 

Обратите внимание, что это inspect.cleandoc также расширяет внутренние табуляции до пробелов.
Это может быть неуместно для конкретного варианта использования, но для меня работает нормально.

То, что следует за первой строкой многострочной строки, является частью строки и не обрабатывается синтаксическим анализатором как отступ. Вы можете свободно писать:

 def main():
    """foo
bar
foo2"""
    pass
 

и это будет правильно.

С другой стороны, это не читается, и Python это знает. Итак, если строка документа содержит пробелы во второй строке, это количество пробелов удаляется при help() просмотре строки документа. Таким образом, help(main) и приведенное ниже help(main2) дает ту же справочную информацию.

 def main2():
    """foo
    bar
    foo2"""
    pass
 

Показ разницы между textwrap.dedent и inspect.cleandoc с немного большей ясностью:

Поведение с начальной частью без отступа

 import textwrap
import inspect

string1="""String
with
no indentation
       """
string2="""String
        with
        indentation
       """
print('string1 plain='   repr(string1))
print('string1 inspect.cleandoc='   repr(inspect.cleandoc(string1)))
print('string1 texwrap.dedent='   repr(textwrap.dedent(string1)))
print('string2 plain='   repr(string2))
print('string2 inspect.cleandoc='   repr(inspect.cleandoc(string2)))
print('string2 texwrap.dedent='   repr(textwrap.dedent(string2)))
 

Вывод

 string1 plain='Stringnwithnno indentationn       '
string1 inspect.cleandoc='Stringnwithnno indentationn       '
string1 texwrap.dedent='Stringnwithnno indentationn'
string2 plain='Stringn        withn        indentationn       '
string2 inspect.cleandoc='Stringnwithnindentation'
string2 texwrap.dedent='Stringn        withn        indentationn'
 

Поведение с отступом в начальной части

 string1="""
String
with
no indentation
       """
string2="""
        String
        with
        indentation
       """

print('string1 plain='   repr(string1))
print('string1 inspect.cleandoc='   repr(inspect.cleandoc(string1)))
print('string1 texwrap.dedent='   repr(textwrap.dedent(string1)))
print('string2 plain='   repr(string2))
print('string2 inspect.cleandoc='   repr(inspect.cleandoc(string2)))
print('string2 texwrap.dedent='   repr(textwrap.dedent(string2)))
 

Вывод

 string1 plain='nStringnwithnno indentationn       '
string1 inspect.cleandoc='Stringnwithnno indentationn       '
string1 texwrap.dedent='nStringnwithnno indentationn'
string2 plain='n        Stringn        withn        indentationn       '
string2 inspect.cleandoc='Stringnwithnindentation'
string2 texwrap.dedent='nStringnwithnindentationn'
 

Я хотел сохранить именно то, что находится между строками в тройных кавычках, удалив только общий начальный отступ. Я нашел это texwrap.dedent и inspect.cleandoc сделал это не совсем правильно, поэтому я написал это. Он использует os.path.commonprefix .

 import re
from os.path import commonprefix

def ql(s, eol=True):
    lines = s.splitlines()
    l0 = None
    if lines:
        l0 = lines.pop(0) or None
    common = commonprefix(lines)
    indent = re.match(r's*', common)[0]
    n = len(indent)
    lines2 = [l[n:] for l in lines]
    if not eol and lines2 and not lines2[-1]:
        lines2.pop()
    if l0 is not None:
        lines2.insert(0, l0)
    s2 = "n".join(lines2)
    return s2
 

Это может заключать в кавычки любую строку с любым отступом. Я хотел, чтобы он включал завершающую новую строку по умолчанию, но с возможностью ее удаления, чтобы она могла аккуратно заключать в кавычки любую строку.

Пример:

 print(ql("""
     Hello
    |---/|
    | o_o |
     _^_/
    """))

print(ql("""
         World
        |---/|
        | o_o |
         _^_/
    """))
 

Вторая строка имеет 4 пробела общего отступа, потому что конечный """ отступ меньше, чем текст в кавычках:

  Hello
|---/|
| o_o |
 _^_/

     World
    |---/|
    | o_o |
     _^_/
 

Я думал, что это будет проще, иначе я бы не стал этим заниматься!

Единственный способ, который я вижу, — это удалить первые n вкладок для каждой строки, начиная со второй, где n — известная идентификация метода main.

Если это обозначение не известно заранее — вы можете добавить завершающую новую строку перед ее вставкой и удалить количество табуляций из последней строки…

Третье решение состоит в том, чтобы проанализировать данные и найти начало многострочной кавычки и не добавлять свой идентификатор в каждую строку после, пока он не будет закрыт.

Думаю, есть лучшее решение..

У меня была похожая проблема: я хотел, чтобы моя строка в тройных кавычках имела отступ, но я не хотел, чтобы в строке были все эти пробелы в начале каждой строки. Раньше я re исправлял свою проблему:

         print(re.sub('n *','n', f"""Content-Type: multipart/mixed; boundary="===============9004758485092194316=="
`           MIME-Version: 1.0
            Subject: Get the reader's attention here!
            To: recipient@email.com

            --===============9004758485092194316==
            Content-Type: text/html; charset="us-ascii"
            MIME-Version: 1.0
            Content-Transfer-Encoding: 7bit

            Very important message goes here - you can even use <b>HTML</b>.
            --===============9004758485092194316==--
        """))
 

Выше я смог сохранить отступ в своем коде, но строка была существенно обрезана. Все пробелы в начале каждой строки были удалены. Это было важно, поскольку любые пробелы перед строками, специфичными для SMTP или MIME, прерывали сообщение электронной почты.

Компромисс, который я сделал, заключался в том, что я оставил Content-Type в первой строке, потому regex что используемый мной не удалял начальный n (который сломал электронную почту). Если бы это меня достаточно беспокоило, я думаю, я мог бы добавить lstrip следующим образом:

 print(re.sub('n *','n', f"""
    Content-Type: ...
""").lstrip()
 

Прочитав эту страницу 10-летней давности, я решил придерживаться, re.sub поскольку я действительно не понимал всех нюансов textwrap и inspect .

Есть гораздо более простой способ:

     foo = """first line
             nsecond line"""
 

Итак, если я правильно понял, вы берете все, что вводит пользователь, делаете правильный отступ и добавляете его к остальной части вашей программы (а затем запускаете всю эту программу).

Итак, после того, как вы введете пользовательский ввод в свою программу, вы можете запустить регулярное выражение, которое в основном возвращает этот принудительный отступ. Что-то вроде: в трех кавычках замените все «маркеры новой строки», за которыми следуют четыре пробела (или табуляция), только «маркером новой строки».