Pythonic способ создания длинной многострочной строки

У меня очень длинный запрос. Я хотел бы разбить его на несколько строк в Python. Способ сделать это в JavaScript - использовать несколько предложений и объединить их с +оператором (я знаю, может быть, это не самый эффективный способ сделать это, но я не особо беспокоюсь о производительности на этом этапе, просто читаемость кода) , Пример:

var long_string = 'some text not important. just garbage to' +
                  'illustrate my example';

Я пытался сделать что-то подобное в Python, но это не сработало, поэтому я использовал \для разделения длинной строки. Тем не менее, я не уверен, что это единственный / лучший / питонический способ сделать это. Это выглядит неловко. Актуальный код:

query = 'SELECT action.descr as "action", '\
    'role.id as role_id,'\
    'role.descr as role'\
    'FROM '\
    'public.role_action_def,'\
    'public.role,'\
    'public.record_def, '\
    'public.action'\
    'WHERE role.id = role_action_def.role_id AND'\
    'record_def.id = role_action_def.def_id AND'\
    'action.id = role_action_def.action_id AND'\
    'role_action_def.account_id = ' + account_id + ' AND'\
    'record_def.account_id=' + account_id + ' AND'\
    'def_id=' + def_id

Вы говорите о многострочных строках? Легко, используйте тройные кавычки, чтобы начать и закончить их.

s = """ this is a very
        long string if I had the
        energy to type more and more ..."""

Вы также можете использовать одинарные кавычки (3 из них, конечно, в начале и в конце) и обрабатывать полученную строку так sже, как любую другую строку.

ПРИМЕЧАНИЕ . Как и в случае с любой строкой, все, что находится между начальной и конечной кавычками, становится частью строки, поэтому в этом примере есть начальный пробел (на что указывает @ root45). Эта строка также будет содержать пробелы и переводы строк.

Т.е. ,:

' this is a very\n        long string if I had the\n        energy to type more and more ...'

Наконец, можно также построить длинные строки в Python следующим образом:

 s = ("this is a very"
      "long string too"
      "for sure ..."
     )

который не будет содержать никаких дополнительных пробелов или новых строк (это преднамеренный пример, показывающий, к чему приведет эффект пропуска пробелов):

'this is a verylong string toofor sure ...'

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

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

query = ('SELECT   action.descr as "action", '
         'role.id as role_id,'
         'role.descr as role'
         ' FROM '
         'public.role_action_def,'
         'public.role,'
         'public.record_def, '
         'public.action'
         ' WHERE role.id = role_action_def.role_id AND'
         ' record_def.id = role_action_def.def_id AND'
         ' action.id = role_action_def.action_id AND'
         ' role_action_def.account_id = '+account_id+' AND'
         ' record_def.account_id='+account_id+' AND'
         ' def_id='+def_id)

В операторе SQL, подобном тому, что вы строите, многострочные строки также подойдут. Но если бы дополнительный пробел, содержащийся в многострочной строке, был бы проблемой, тогда это был бы хороший способ достичь того, чего вы хотите.

Прерывание линий \работает для меня. Вот пример:

longStr = "This is a very long string " \
        "that I wrote to help somebody " \
        "who had a question about " \
        "writing long strings in Python"

Я нашел себя счастливым с этим:

string = """This is a
very long string,
containing commas,
that I split up
for readability""".replace('\n',' ')

Я обнаружил, что при построении длинных строк вы обычно делаете что-то вроде создания SQL-запроса, и в этом случае это лучше всего:

query = ' '.join((  # note double parens, join() takes an iterable
    "SELECT foo",
    "FROM bar",
    "WHERE baz",
))

То, что предложил Левон, хорошо, но может быть уязвимо для ошибок:

query = (
    "SELECT foo"
    "FROM bar"
    "WHERE baz"
)

query == "SELECT fooFROM barWHERE baz"  # probably not what you want

Вы также можете объединять переменные при использовании нотации "" ":

foo = '1234'

long_string = """fosdl a sdlfklaskdf as
as df ajsdfj asdfa sld
a sdf alsdfl alsdfl """ +  foo + """ aks
asdkfkasdk fak"""

РЕДАКТИРОВАТЬ: нашел лучший способ, с именованными параметрами и .format ():

body = """
<html>
<head>
</head>
<body>
    <p>Lorem ipsum.</p>
    <dl>
        <dt>Asdf:</dt>     <dd><a href="{link}">{name}</a></dd>
    </dl>
    </body>
</html>
""".format(
    link='http://www.asdf.com',
    name='Asdf',
)

print(body)

Этот подход использует:

• только одна обратная косая черта, чтобы избежать начального перевода строки
• почти нет внутренней пунктуации при использовании строки в тройных кавычках
• удаляет локальный отступ с помощью inspect модуля textwrap
• использование Python 3.6 отформатированной строки интерполяции ( «F») для account_idи def_idпеременных.

Этот способ выглядит наиболее питонным для меня.

# import textwrap  # See update to answer below
import inspect

# query = textwrap.dedent(f'''\
query = inspect.cleandoc(f'''
    SELECT action.descr as "action", 
    role.id as role_id,
    role.descr as role
    FROM 
    public.role_action_def,
    public.role,
    public.record_def, 
    public.action
    WHERE role.id = role_action_def.role_id AND
    record_def.id = role_action_def.def_id AND
    action.id = role_action_def.action_id AND
    role_action_def.account_id = {account_id} AND
    record_def.account_id={account_id} AND
    def_id={def_id}'''
)

Обновление : 29.01.2009 Включить предложение @ ShadowRanger для использования inspect.cleandocвместоtextwrap.dedent

В Python> = 3.6 вы можете использовать форматированные строковые литералы (f строка)

query= f'''SELECT   action.descr as "action"
    role.id as role_id,
    role.descr as role
    FROM
    public.role_action_def,
    public.role,
    public.record_def,
    public.action
    WHERE role.id = role_action_def.role_id AND
    record_def.id = role_action_def.def_id AND
    action.id = role_action_def.action_id AND
    role_action_def.account_id = {account_id} AND
    record_def.account_id = {account_id} AND
    def_id = {def_id}'''

Например:

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1={} "
       "and condition2={}").format(1, 2)

Output: 'select field1, field2, field3, field4 from table 
         where condition1=1 and condition2=2'

если значение условия должно быть строкой, вы можете сделать это так:

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1='{0}' "
       "and condition2='{1}'").format('2016-10-12', '2017-10-12')

Output: "select field1, field2, field3, field4 from table where
         condition1='2016-10-12' and condition2='2017-10-12'"

Я нахожу textwrap.dedentлучшее для длинных строк, как описано здесь :

def create_snippet():
    code_snippet = textwrap.dedent("""\
        int main(int argc, char* argv[]) {
            return 0;
        }
    """)
    do_something(code_snippet)

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

Комментарий к каждому фрагменту:

nursery_rhyme = (
    'Mary had a little lamb,'          # Comments are great!
    'its fleece was white as snow.'
    'And everywhere that Mary went,'
    'her sheep would surely go.'       # What a pesky sheep.
)

Комментарий не разрешен после продолжения:

При использовании продолжения строки с обратной косой чертой ( \) комментарии не допускаются. Вы получите SyntaxError: unexpected character after line continuation characterошибку.

nursery_rhyme = 'Mary had a little lamb,' \  # These comments
    'its fleece was white as snow.'       \  # are invalid!
    'And everywhere that Mary went,'      \
    'her sheep would surely go.'
# => SyntaxError: unexpected character after line continuation character

Лучшие комментарии для строк Regex:

Основываясь на примере с https://docs.python.org/3/library/re.html#re.VERBOSE ,

a = re.compile(
    r'\d+'  # the integral part
    r'\.'   # the decimal point
    r'\d*'  # some fractional digits
)

# Using VERBOSE flag, IDE usually can't syntax highight the string comment.
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)

Лично я считаю, что следующий способ - лучший (простой, безопасный и Pythonic) способ написания необработанных SQL-запросов на Python, особенно при использовании модуля sqlite3 в Python :

query = '''
    SELECT
        action.descr as action,
        role.id as role_id,
        role.descr as role
    FROM
        public.role_action_def,
        public.role,
        public.record_def,
        public.action
    WHERE
        role.id = role_action_def.role_id
        AND record_def.id = role_action_def.def_id
        AND action.id = role_action_def.action_id
        AND role_action_def.account_id = ?
        AND record_def.account_id = ?
        AND def_id = ?
'''
vars = (account_id, account_id, def_id)   # a tuple of query variables
cursor.execute(query, vars)   # using Python's sqlite3 module

Pros

• Аккуратный и простой код (Pythonic!)
• Сейф от внедрения SQL
• Совместим с Python 2 и Python 3 (это Pythonic в конце концов)
• Конкатенация строк не требуется
• Не нужно гарантировать, что самый правый символ каждой строки является пробелом

Cons

• Поскольку переменные в запросе заменяются ?местозаполнителем, может оказаться немного сложным отследить, какую из них ?заменить какой переменной Python, когда их много в запросе.

Я обычно использую что-то вроде этого:

text = '''
    This string was typed to be a demo
    on how could we write a multi-line
    text in Python.
'''

Если вы хотите удалить надоедливые пробелы в каждой строке, вы можете сделать следующее:

text = '\n'.join(line.lstrip() for line in text.splitlines())

Ваш фактический код не должен работать, вам не хватает пробельные в конце «линии» (например: role.descr as roleFROM...)

Для многострочной строки есть тройные кавычки:

string = """line
  line2
  line3"""

Он будет содержать разрывы строк и лишние пробелы, но для SQL это не проблема.

Вы также можете поместить SQL-оператор в отдельный файл action.sqlи загрузить его в py-файл с помощью

with open('action.sql') as f:
   query = f.read()

Таким образом, SQL-операторы будут отделены от кода Python. Если в выражении sql есть параметры, которые необходимо заполнить из python, вы можете использовать форматирование строки (например,% s или {field})

Путь "а- ля" Скала (но я думаю, что это самый питонический путь, как того требует OQ):

description = """
            | The intention of this module is to provide a method to 
            | pass meta information in markdown_ header files for 
            | using it in jinja_ templates. 
            | 
            | Also, to provide a method to use markdown files as jinja 
            | templates. Maybe you prefer to see the code than 
            | to install it.""".replace('\n            | \n','\n').replace('            | ',' ')

Если вам нужен последний str без переходов, просто поместите \nв начале первого аргумента второй замены:

.replace('\n            | ',' ')`.

Примечание: белая линия между «... шаблонами». и "Кроме того ..." требует пробела после |.

tl; dr: используйте """\и """для переноса строки , как в

string = """\
This is a long string
spanning multiple lines.
"""

Из официальной документации по питону :

Строковые литералы могут занимать несколько строк. Одним из способов является использование тройных кавычек: "" "..." "" или "" ... ". Конец строк автоматически включается в строку, но это можно предотвратить, добавив \ в конце строки. Следующий пример:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

производит следующий вывод (обратите внимание, что начальный перевод строки не включен):

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

Эй, попробуйте что-то вроде этой надежды, это работает, как в этом формате, он вернет вам непрерывную строку, как вы успешно спросили об этом свойстве`

"message": f'you have successfully inquired about '
           f'{enquiring_property.title} Property owned by '
           f'{enquiring_property.client}'

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

# Utility function to recursively resolve SQL statements.
# CAUTION: Use this function carefully, Pass correct SQL parameters {},
# TODO: This should never happen but check for infinite loops
def resolveSQL(sql_seed, sqlparams):
    sql = sql_seed % (sqlparams)
    if sql == sql_seed:
        return ' '.join([x.strip() for x in sql.split()])
    else:
        return resolveSQL(sql, sqlparams)

PS: взгляните на потрясающую библиотеку python-sqlparse, чтобы при необходимости распечатывать запросы SQL. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

Другой вариант, который, на мой взгляд, более читабелен, когда код (например, переменная) имеет отступ, а выходная строка должна быть однострочной (без новых строк):

def some_method():

    long_string = """
a presumptuous long string 
which looks a bit nicer 
in a text editor when
written over multiple lines
""".strip('\n').replace('\n', ' ')

    return long_string 

Используйте тройные кавычки. Люди часто используют их для создания строк документации в начале программы, чтобы объяснить их назначение и другую информацию, относящуюся к ее созданию. Люди также используют их в функциях, чтобы объяснить назначение и применение функций. Пример:

'''
Filename: practice.py
File creator: me
File purpose: explain triple quotes
'''


def example():
    """This prints a string that occupies multiple lines!!"""
    print("""
    This
    is 
    a multi-line
    string!
    """)

Мне нравится этот подход, потому что он дает право на чтение. В тех случаях, когда у нас длинные струны, это невозможно! В зависимости от уровня отступа вы находитесь и до сих пор ограничены 80 символами в строке ... Ну ... Больше ничего не нужно говорить. На мой взгляд, руководства по питонскому стилю все еще очень расплывчаты. Я выбрал подход @Eero Aaltonen, потому что он дает преимущество в чтении и здравом смысле. Я понимаю, что руководства по стилю должны помочь нам, а не сделать нашу жизнь беспорядочной. Спасибо!

class ClassName():
    def method_name():
        if condition_0:
            if condition_1:
                if condition_2:
                    some_variable_0 =\
"""
some_js_func_call(
    undefined, 
    {
        'some_attr_0': 'value_0', 
        'some_attr_1': 'value_1', 
        'some_attr_2': '""" + some_variable_1 + """'
    }, 
    undefined, 
    undefined, 
    true
)
"""

Из официальной документации по питону :

Строковые литералы могут занимать несколько строк. Одним из способов является использование тройных кавычек: "" "..." "" или "" ... ". Конец строк автоматически включается в строку, но это можно предотвратить, добавив \ в конце строки. Следующий пример:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

производит следующий вывод (обратите внимание, что начальный перевод строки не включен):

Для определения длинной строки внутри dict, сохранения новых строк, но без пробелов , я в итоге определил строку в константе, подобной этой:

LONG_STRING = \
"""
This is a long sting
that contains newlines.
The newlines are important.
"""

my_dict = {
   'foo': 'bar',
   'string': LONG_STRING
}

В качестве общего подхода к длинным строкам в Python вы можете использовать тройные кавычки splitи join:

_str = ' '.join('''Lorem ipsum dolor sit amet, consectetur adipiscing 
        elit, sed do eiusmod tempor incididunt ut labore et dolore 
        magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation 
        ullamco laboris nisi ut aliquip ex ea commodo.'''.split())

Вывод:

'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo.'

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

Используя тройные кавычки, мы строим длинную и читаемую строку, которую затем разбиваем на список, используя split()таким образом пробелы и затем соединяем их вместе ' '.join(). Наконец, мы вставляем переменные с помощью format()команды:

account_id = 123
def_id = 321

_str = '''
    SELECT action.descr AS "action", role.id AS role_id, role.descr AS role 
    FROM public.role_action_def, public.role, public.record_def, public.action
    WHERE role.id = role_action_def.role_id 
    AND record_def.id = role_action_def.def_id 
    AND' action.id = role_action_def.action_id 
    AND role_action_def.account_id = {} 
    AND record_def.account_id = {} 
    AND def_id = {}
    '''

query = ' '.join(_str.split()).format(account_id, account_id, def_id)

Производит:

SELECT action.descr AS "action", role.id AS role_id, role.descr AS role FROM public.role_action_def, public.role, public.record_def, public.action WHERE role.id = role_action_def.role_id AND record_def.id = role_action_def.def_id AND\' action.id = role_action_def.action_id AND role_action_def.account_id = 123 AND record_def.account_id=123 AND def_id=321

Изменить: этот подход не соответствует PEP8, но я считаю его полезным иногда

Вообще, я использую listи joinдля многострочных комментариев / строк.

lines = list()
lines.append('SELECT action.enter code here descr as "action", ')
lines.append('role.id as role_id,')
lines.append('role.descr as role')
lines.append('FROM ')
lines.append('public.role_action_def,')
lines.append('public.role,')
lines.append('public.record_def, ')
lines.append('public.action')
query = " ".join(lines)

Вы можете использовать любую строку, чтобы присоединиться ко всему этому элементу списка, например ' \n' (новая строка ) или ' ,' (запятая) или ' ' (пробел)

Ура .. !!