我知道我应该将 Python 代码保持在 79 列，但是如何缩进连续行呢？

Question

我知道 Python 的标准行宽约定是 79 个字符。我知道行可以通过多种方式继续，例如自动字符串连接、括号和反斜杠。似乎没有明确定义的是溢出文本应该如何格式化。我要把它一直推回到第 1 栏吗？到原始行开始的那一栏？到括号的开头（如果适用）？例如，假设我有这样的内容：

        self.someLongAttributeName = {'someLongKeyName':'someLongValueName',
                                      'anotherLongKeyName':'anotherLongValueName'}

假设我上面使用的格式符合 79 个字符的限制，那么第二行的缩进是否正确？

现在假设如上所示的第一行是 > 79 个字符。在这种情况下，情况应该如何？

注意：我知道很多人不同意 79 个字符的约定。虽然我尊重这个问题的每一方都有很多优点和缺点，但这场辩论与我的问题无关。我问的是如何遵循惯例，而不是我是否应该遵循惯例，所以请不要在回复中宣扬放弃惯例的好处。谢谢。 =)

Answer 1

假设我上面使用的格式符合 79 个字符的限制，那么第二行的缩进是否正确？

是的，这就是 PEP 8 在示例中的显示方式：

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)

但是当左括号/大括号已经接近第 79 列时，我通常只是利用这一点：

Two good reasons to break a particular rule:

(1) When applying the rule would make the code less readable, even for
    someone who is used to reading code that follows the rules.
[...]

并执行类似

self.some_long_attribute_name = {
    'someLongKeyName': 'someLongValueName',
    'anotherLongKeyName': 'anotherLongValueName'
}

或的操作

long_object_name.do_something_with_long_name(
    long_expression_returning_is_first_arg,
    long_expression_returning_is_second_arg
)

Answer 2

http://www.python.org/dev/peps/pep-0008/< /a>
请参阅最大行长度

将所有行限制为最多 79 行
字符。

周围还有很多设备
限制为 80 个字符
线路；另外，将窗口限制为 80
字符使得有可能拥有
几个并排的窗口。这
此类设备上的默认换行
破坏了视觉结构
代码，使得更难
理解。因此，请限制
所有行最多 79
人物。对于流动的长块
文本（文档字符串或注释），
将长度限制为 72 个字符
推荐。

长包裹的首选方式
lines 是通过使用 Python 隐含的 line
括号内继续，
括号和大括号。如果有需要的话，
你可以添加一对额外的
表达式两边有括号，但是
有时使用反斜杠看起来
更好的。确保缩进
适当地继续行。这
休息的首选地点
二元运算符是
在运算符之后，而不是之前。一些例子：

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)

Answer 3

即使在 Python 之外，我也一直对 C 代码执行此操作，这样我就可以（如 PEP 所说）在监视器上并排打开 2-3 个文件并查看所有文件。

反斜杠运算符 \ 在 Python 和 C 中用作行继续运算符，但我更喜欢尝试使用括号 () 或大括号 {} 将行分组 （或者 Python 列表的方括号 []），无论什么都是最方便的。如果我决定要在一个长连续块的中间添加另一行，我不想担心任何愚蠢的“陷阱”：缺少 \ 或更糟糕的是，在\ 使延续无效。

对于长条件语句，我喜欢双缩进，这样更明显的是该代码不是新块的一部分。

if (somethingLong == x or
        somethingElse == y or
        somethingOld == z or
        x < y < z or
        doIt.now()):
    pass

Answer 4

在PEP 8中有一个例子：

class Rectangle(Blob):

    def __init__(self, width, height,
        # more code
        Blob.__init__(self, width, height,
                      color, emphasis, highlight)

在我看来，这表明你的例子是正确的。我认为你应该在打开括号（ { ）后打破示例的第一行，如下所示：

    self.someLongAttributeName = {
                 'someLongKeyName':'someLongValueName',
                 'anotherLongKeyName':'anotherLongValueName'
    }

如果它太长。我不知道它是否是“pythonic”，但应该是熟悉和可读的。

Answer 5

长包裹的首选方式
行是通过使用Python的隐含
线
括号、方括号和大括号内的延续。如果有需要的话，
你
可以在表达式周围添加一对额外的括号，但是
有时
使用反斜杠看起来更好。确保缩进续行
适当地。破解二进制文件的首选位置
运算符是
在运算符之后，而不是在其之前。

Answer 6

我很确定这个问题之前已经在这里得到了回答，但我现在找不到它了。

简短的答案是 PEP8 不包括如何格式化对象文字，除了冒号之前应该有零个空格，之后有一个空格。

我这样做：

obj = {
     'foo': 1,
     'bar': 2,
     'bas': 3,
}

Answer 7

这样做的好技巧也是这样：

my_long_string="""
This are
many lines of text
"""

a = [a in my_long_string.split() if a]

有些人喜欢在打开三重引号后使用 \，而不是过滤空行，但我真的很讨厌那些野兽。

对于你的具体例子，我同意cji。