我有一行很长的代码，我想在多行中分解。我使用什么，语法是什么？

例如，添加一组字符串，

把它分成两行：

线路是什么？您可以在下一行使用参数，而不会出现任何问题：

否则，您可以这样做：

有关详细信息，请查看样式指南。

从示例行：

或：

请注意，样式指南指出，最好使用带括号的隐式延续，但在这种特殊情况下，在表达式周围添加括号可能是错误的做法。

从python代码的样式指南：

The preferred way of wrapping long lines is by using Python's implied line continuation inside parentheses, brackets and braces. Long lines can be broken over multiple lines by wrapping expressions in parentheses. These should be used in preference to using a backslash for line continuation.

Backslashes may still be appropriate at times. For example, long, multiple with-statements cannot use implicit continuation, so backslashes are acceptable:

1 2 3

with open('/path/to/some/file/you/want/to/read') as file_1, \         open('/path/to/some/file/being/written', 'w') as file_2:     file_2.write(file_1.read())

Another such case is with assert statements.

Make sure to indent the continued line appropriately. The preferred place to break around a binary operator is after the operator, not before it. Some examples:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Rectangle(Blob):     def __init__(self, width, height,                  color='black', emphasis=None, highlight=0):         if (width == 0 and height == 0 and                 color == 'red' and emphasis == 'strong' or                 highlight > 100):             raise ValueError("sorry, you lose")         if width == 0 and height == 0 and (color == 'red' or                                            emphasis is None):             raise ValueError("I don't think so -- values are %s, %s" %                              (width, height))         Blob.__init__(self, width, height,                       color, emphasis, highlight)

编辑：PEP8现在建议数学家和他们的出版商使用相反的约定(用于打破二进制运算)，以提高可读性。

DonaldKnuth在二元运算符垂直对齐之前的中断方式，从而在确定添加和减去哪些项时减少了眼睛的工作量。

来自PEP8：在二元运算符之前还是之后换行？：

Donald Knuth explains the traditional rule in his Computers and Typesetting series:"Although formulas within a paragraph always break after binary operations and relations, displayed formulas always break before binary operations"[3].

Following the tradition from mathematics usually results in more readable code:

1 2 3 4 5 6

# Yes: easy to match operators with operands income = (gross_wages           + taxable_interest           + (dividends - qualified_dividends)           - ira_deduction           - student_loan_interest)

In Python code, it is permissible to break before or after a binary operator, as long as the convention is consistent locally. For new code Knuth's style is suggested.

【3】：唐纳德·克努斯的《特克斯本》，第195和196页。

使用反斜杠结束一行的危险是，如果在反斜杠后面加上空格(当然，很难看到)，反斜杠就不再像你想象的那样做了。

有关更多信息，请参见python惯用法和反惯用法(针对python 2或python 3)。

可以在括号和大括号之间换行。此外，还可以将反斜杠字符\附加到一行，以显式中断该行：

在行尾放一个\，或将声明附在parens ( .. )中。来自IBM：

或

From the horse's mouth: Explicit line
joining

Two or more physical lines may be
joined into logical lines using
backslash characters (\), as follows:
when a physical line ends in a
backslash that is not part of a string
literal or comment, it is joined with
the following forming a single logical
line, deleting the backslash and the
following end-of-line character. For
example:

1 2 3 4

if 1900 < year < 2100 and 1 <= month <= 12 \    and 1 <= day <= 31 and 0 <= hour < 24 \    and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date         return 1

A line ending in a backslash cannot
carry a comment. A backslash does not
continue a comment. A backslash does
not continue a token except for string
literals (i.e., tokens other than
string literals cannot be split across
physical lines using a backslash). A
backslash is illegal elsewhere on a
line outside a string literal.

可能不是pythonic方法，但我通常使用带有join函数的list来编写像SQL查询这样的长字符串。

摘自《Python漫游指南》(续行)：

When a logical line of code is longer than the accepted limit, you need to split it over multiple physical lines. The Python interpreter will join consecutive lines if the last character of the line is a backslash. This is helpful in some cases, but should usually be avoided because of its fragility: a white space added to the end of the line, after the backslash, will break the code and may have unexpected results.

A better solution is to use parentheses around your elements. Left with an unclosed parenthesis on an end-of-line the Python interpreter will join the next line until the parentheses are closed. The same behaviour holds for curly and square braces.

However, more often than not, having to split a long logical line is a sign that you are trying to do too many things at the same time, which may hinder readability.

也就是说，这里有一个关于多重进口的例子(当超过PEP-8中定义的行限制时)：