Cách Pythonic để tạo một chuỗi nhiều dòng dài

Tôi có một truy vấn rất dài. Tôi muốn chia nó thành nhiều dòng trong Python. Một cách để làm điều đó trong JavaScript sẽ là sử dụng một số câu và nối chúng với một +toán tử (tôi biết, có thể đó không phải là cách hiệu quả nhất để làm điều đó, nhưng tôi không thực sự quan tâm đến hiệu suất trong giai đoạn này, chỉ là khả năng đọc mã) . Thí dụ:

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

Tôi đã thử làm một cái gì đó tương tự trong Python, nhưng nó không hoạt động, vì vậy tôi đã sử dụng \để tách chuỗi dài. Tuy nhiên, tôi không chắc đây có phải là cách duy nhất / tốt nhất / pythonicest không. Có vẻ lúng túng. Mã thực tế:

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

Bạn đang nói về chuỗi nhiều dòng? Dễ dàng, sử dụng ba dấu ngoặc kép để bắt đầu và kết thúc chúng.

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

Bạn cũng có thể sử dụng các trích dẫn đơn (tất nhiên 3 trong số chúng ở đầu và cuối) và coi chuỗi kết quả sgiống như bất kỳ chuỗi nào khác.

LƯU Ý : Giống như với bất kỳ chuỗi nào, mọi thứ giữa dấu ngoặc kép bắt đầu và kết thúc đều trở thành một phần của chuỗi, vì vậy ví dụ này có khoảng trống hàng đầu (như được chỉ ra bởi @ root45). Chuỗi này cũng sẽ chứa cả khoảng trống và dòng mới.

I E,:

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

Cuối cùng, người ta cũng có thể xây dựng các dòng dài trong Python như thế này:

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

trong đó sẽ không bao gồm bất kỳ khoảng trống hoặc dòng mới nào (đây là một ví dụ có chủ ý cho thấy hiệu ứng của việc bỏ trống sẽ dẫn đến kết quả gì):

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

Không yêu cầu dấu phẩy, chỉ cần đặt các chuỗi được nối với nhau thành một cặp dấu ngoặc đơn và đảm bảo tính đến mọi khoảng trống và dòng mới cần thiết.

Nếu bạn không muốn một chuỗi nhiều dòng nhưng chỉ có một chuỗi dòng đơn dài, bạn có thể sử dụng dấu ngoặc đơn, chỉ cần đảm bảo rằng bạn không bao gồm dấu phẩy giữa các phân đoạn chuỗi, sau đó sẽ là một tuple.

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)

Trong một câu lệnh SQL giống như những gì bạn đang xây dựng, các chuỗi nhiều dòng cũng sẽ ổn. Nhưng nếu khoảng trắng thêm một chuỗi nhiều dòng sẽ là một vấn đề, thì đây sẽ là một cách tốt để đạt được những gì bạn muốn.

Phá vỡ dòng bằng cách \làm việc cho tôi. Đây là một ví dụ:

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

Tôi thấy mình hạnh phúc với điều này:

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

Tôi thấy rằng khi xây dựng chuỗi dài, bạn thường làm một việc gì đó như xây dựng truy vấn SQL, trong trường hợp này là tốt nhất:

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

Những gì Levon đề xuất là tốt, nhưng có thể dễ bị mắc lỗi:

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

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

Bạn cũng có thể nối các biến khi sử dụng ký hiệu "" ":

foo = '1234'

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

EDIT: Tìm thấy một cách tốt hơn, với params và .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)

Cách tiếp cận này sử dụng:

• chỉ cần một dấu gạch chéo ngược để tránh một nguồn cấp dữ liệu ban đầu
• hầu như không có dấu câu nội bộ bằng cách sử dụng chuỗi trích dẫn ba
• loại bỏ thụt cục bộ bằng cách sử dụng mô-đun textwrap inspect
• sử dụng phép nội suy chuỗi định dạng python 3.6 ('f') cho các biến account_idvà def_id.

Cách này có vẻ là pythonic nhất đối với tôi.

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

Cập nhật : 1/29/2019 Kết hợp đề xuất @ ShadowRanger để sử dụng inspect.cleandocthay vìtextwrap.dedent

Trong Python> = 3.6, bạn có thể sử dụng chuỗi ký tự được định dạng (chuỗi 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}'''

Ví dụ:

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'

Nếu giá trị của điều kiện phải là một chuỗi, bạn có thể làm như thế này:

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

Tôi tìm thấy textwrap.dedenttốt nhất cho chuỗi dài như được mô tả ở đây :

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

Những người khác đã đề cập đến phương thức dấu ngoặc đơn, nhưng tôi muốn thêm rằng với dấu ngoặc đơn, cho phép nhận xét nội tuyến.

Nhận xét về từng mảnh:

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

Bình luận không được phép sau khi tiếp tục:

Khi sử dụng tiếp tục dòng dấu gạch chéo ngược ( \), các bình luận không được phép. Bạn sẽ nhận được một SyntaxError: unexpected character after line continuation characterlỗi.

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

Nhận xét tốt hơn cho chuỗi Regex:

Dựa trên ví dụ từ https://docs.python.org/3/l 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)

Cá nhân tôi thấy sau đây là cách tốt nhất (đơn giản, an toàn và Pythonic) để viết các truy vấn SQL thô trong Python, đặc biệt là khi sử dụng mô-đun sqlite3 của 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

Ưu

• Mã gọn gàng và đơn giản (Pythonic!)
• An toàn từ SQL tiêm
• Tương thích với cả Python 2 và Python 3 (rốt cuộc là Pythonic)
• Không cần nối chuỗi
• Không cần phải đảm bảo rằng ký tự bên phải của mỗi dòng là khoảng trắng

Nhược điểm

• Do các biến trong truy vấn được thay thế bởi ?trình giữ chỗ, nên có thể hơi khó theo dõi biến nào ?sẽ được thay thế bằng biến Python nào khi có nhiều biến trong truy vấn.

Tôi thường sử dụng một cái gì đó như thế này:

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

Nếu bạn muốn xóa các khoảng trống khó chịu trong mỗi dòng, bạn có thể làm như sau:

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

Mã thực tế của bạn không hoạt động, bạn đang thiếu khoảng trắng ở cuối "dòng" (ví dụ role.descr as roleFROM...:)

Có ba chuỗi cho chuỗi đa dòng:

string = """line
  line2
  line3"""

Nó sẽ chứa các ngắt dòng và khoảng trắng thừa, nhưng đối với SQL đó không phải là vấn đề.

Bạn cũng có thể đặt câu lệnh sql trong một tệp riêng biệt action.sqlvà tải nó trong tệp py với

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

Vì vậy, các câu lệnh sql sẽ được tách ra khỏi mã python. Nếu có các tham số trong câu lệnh sql cần điền từ python, bạn có thể sử dụng định dạng chuỗi (như% s hoặc {field})

"À la" Scala way (nhưng tôi nghĩ là cách pythonic nhất theo yêu cầu của 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('            | ',' ')

Nếu bạn muốn str cuối cùng không có dòng nhảy, chỉ cần đặt \nở đầu của đối số thứ nhất của thay thế thứ hai:

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

Lưu ý: đường trắng giữa "... mẫu." và "Ngoài ra, ..." yêu cầu một khoảng trắng sau |.

tl; dr: Sử dụng """\và """để quấn chuỗi , như trong

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

Từ tài liệu chính thức về trăn :

Chuỗi ký tự có thể trải dài trên nhiều dòng. Một cách là sử dụng ba dấu ngoặc kép: "" "..." "" hoặc '' '...' ''. Cuối dòng được tự động đưa vào chuỗi, nhưng có thể ngăn chặn điều này bằng cách thêm \ ở cuối dòng. Ví dụ sau:

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

tạo đầu ra sau (lưu ý rằng dòng mới ban đầu không được bao gồm):

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

Hãy thử một cái gì đó như thế này hy vọng nó hoạt động, như trong định dạng này, nó sẽ trả về cho bạn một dòng liên tục như bạn đã hỏi thành công về tài sản này '

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

Tôi sử dụng hàm đệ quy để xây dựng các Truy vấn SQL phức tạp. Kỹ thuật này thường có thể được sử dụng để xây dựng các chuỗi lớn trong khi vẫn duy trì khả năng đọc mã.

# 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: Hãy xem thư viện python-sqlparse tuyệt vời để in các truy vấn SQL đẹp nếu cần. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

Một tùy chọn khác mà tôi nghĩ là dễ đọc hơn khi mã (ví dụ biến) được thụt lề và chuỗi đầu ra phải là một lớp lót (không có dòng mới):

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 

Sử dụng ba dấu ngoặc kép. Mọi người thường sử dụng những thứ này để tạo ra các tài liệu khi bắt đầu các chương trình để giải thích mục đích của họ và các thông tin khác liên quan đến việc tạo ra nó. Mọi người cũng sử dụng chúng trong các chức năng để giải thích mục đích và ứng dụng của các chức năng. Thí dụ:

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

Tôi thích cách tiếp cận này vì nó đặc quyền đọc. Trong trường hợp chúng ta có chuỗi dài thì không có cách nào! Tùy thuộc vào mức độ thụt lề mà bạn tham gia và vẫn giới hạn ở 80 ký tự trên mỗi dòng ... Chà ... Không cần phải nói gì thêm. Theo quan điểm của tôi, hướng dẫn phong cách python vẫn còn rất mơ hồ. Tôi đã sử dụng phương pháp @Eero Aaltonen vì nó đặc quyền đọc và lẽ thường. Tôi hiểu rằng hướng dẫn phong cách sẽ giúp chúng tôi và không làm cho cuộc sống của chúng tôi trở nên lộn xộn. Cảm ơn!

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

Từ tài liệu chính thức về trăn :

Chuỗi ký tự có thể trải dài trên nhiều dòng. Một cách là sử dụng ba dấu ngoặc kép: "" "..." "" hoặc '' '...' ''. Cuối dòng được tự động đưa vào chuỗi, nhưng có thể ngăn chặn điều này bằng cách thêm \ ở cuối dòng. Ví dụ sau:

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

tạo đầu ra sau (lưu ý rằng dòng mới ban đầu không được bao gồm):

Để xác định một chuỗi dài bên trong một dict, giữ các dòng mới nhưng bỏ qua các khoảng trắng , cuối cùng tôi đã xác định chuỗi trong một hằng số như thế này:

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

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

Là một cách tiếp cận chung cho các chuỗi dài trong Python, bạn có thể sử dụng ba dấu ngoặc kép splitvà 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())

Đầu ra:

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

Đối với câu hỏi của OP liên quan đến truy vấn SQL, câu trả lời dưới đây bỏ qua tính chính xác của phương pháp này để xây dựng các truy vấn SQL và chỉ tập trung vào việc xây dựng các chuỗi dài theo cách dễ đọc và thẩm mỹ mà không cần nhập thêm. Nó cũng bỏ qua tải tính toán đòi hỏi này.

Sử dụng ba dấu ngoặc kép, chúng tôi xây dựng một chuỗi dài và có thể đọc được, sau đó chúng tôi chia thành một danh sách bằng cách split()tước bỏ khoảng trắng và sau đó nối nó lại với nhau ' '.join(). Cuối cùng, chúng tôi chèn các biến bằng cách sử dụng format()lệnh:

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)

Sản xuất:

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

Chỉnh sửa: Cách tiếp cận này không phù hợp với PEP8 nhưng đôi khi tôi thấy nó hữu ích

Nói chung, tôi sử dụng listvà joincho các bình luận / chuỗi nhiều dòng.

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)

bạn có thể sử dụng bất kỳ chuỗi nào để tham gia tất cả thành phần danh sách này như ' \n' (dòng mới) hoặc ' ,' (dấu phẩy) hoặc ' ' (dấu cách)

Chúc mừng .. !!