Штирлиц — Сеть печатных салонов в Перми

Весь комплекс печатных услуг в Перми. Общирная сеть печатных салонов в Перми. Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми

Python перенос строки в коде: python — Как перенести строку по правилам PEP8?

python — Перенос длинных строк кода с точкой, как правильно по pep8

Задать вопрос

Вопрос задан

Изменён 2 года 10 месяцев назад

Просмотрен 3k раз

Встал вопрос, как правильно и красиво сделать перенос длинной строки кода по PEP8 в месте точки:

result = list(
    MyModel.objects
        .filter(field1=100)
        .exclude(field2='a')
        .values_list(field3, flat=True))

Пытаюсь сделать так, вставив отступы в начале каждой строки перед точкой. Но autopep8 переформатирует:

result = list(
    MyModel.objects
    .filter(field1=100)
    .exclude(field2='a')
    .values_list(field3, flat=True))

Все бы ничего, но это код, над которым работает команда и она требует единой стилистики.

Либо обосновать, почему надо ее изменить. Пытался искать и ничего не нашел. И да, первый вариант мне кажется более понятным и читаемым. Но если pep8 и в самом деле требует форматирования Вариант 2, то что ж, надо ему следовать. Да и просто при сохранении постоянное переформатирование происходит, а потом перед коммитом в репозиторий его убирать — лишние затраты.

  • python
  • code-style
4

Я в подобных случаях считаю самым удобочитаемым вариант при котором первый же кусочек с точкой идёт с новой строки:

result = list(
    MyModel
    .objects
    .filter(field1=100)
    .exclude(field2='a')
    .values_list(field3, flat=True)
    )

Никаких лишних отступов нет и автопроверка стиля не ругается.

2

Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации

Почта

Необходима, но никому не показывается

By clicking “Отправить ответ”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Запись длинных строк текста на нескольких строках в Python

Если вы используете PEP8-совместимую программу проверки кода, такую как flake8 в Python, вы получите следующую ошибку, если строка превышает 80 символов.E501 line too longЯ покажу вам, как разбить длинную строку из более чем 80 символов, такую как URL, на несколько строк кода.

  • Игнорировать переносы строк с обратными слешами (\)
  • Разрывы строк могут быть свободно заключены в круглые скобки

Модуль textwrap также полезен, если вы хотите выводить и отображать длинные строки, оборачивая или опуская их.
Если у вас есть цепочка методов, длина которой превышает одну строку символов, а не длинная строка, вы можете разорвать строку и в коде.

Table of Contents

  • Игнорировать переносы строк с обратными слешами (\)
  • Разрывы строк могут быть свободно заключены в круглые скобки

Игнорировать переносы строк с обратными слешами (\)

В Python обратный слеш (\) является символом продолжения, и когда он помещается в конец строки, он игнорирует последующие переносы строк и считает, что строка продолжается.

n = 1 + 2 \
    + 3
print(n)
# 6

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

s = 'aaa' 'bbb'
print(s)
# aaabbb

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

s = 'https://wikipedia.org/wiki/'\
    '%E3%83%97%E3%83%AD%E3%82%B0%E3%83'\
    '%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E'
print(s)
# https://wikipedia.org/wiki/%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E

Обратите внимание, что конкатенировать можно только строковые литералы (заключенные в ‘ или «»), а переменные, содержащие строки, приведут к ошибке.

s_var = 'xxx'
# s = 'aaa' s_var 'bbb'
# SyntaxError: invalid syntax

Для конкатенации переменных друг с другом или переменных со строковыми литералами используйте оператор +.

s = 'aaa' + s_var + 'bbb'
print(s)
# aaaxxxbbb

Даже если они разделены обратной косой чертой (\), для объединения переменных требуется оператор +.

s = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\
    + s_var\
    + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
print(s)
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxxxbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Разрывы строк могут быть свободно заключены в круглые скобки

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

  • ()
  • {}
  • []

Обратите внимание, что следующие скобки имеют значение.

  • {} = set
  • [] = list

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

s = ('https://wikipedia.org/wiki/'
     '%E3%83%97%E3%83%AD%E3%82%B0%E3%83'
     '%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E')
print(s)
# https://wikipedia. org/wiki/%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E

Как и в примере с обратной косой чертой, оператор + необходим при включении переменных.

s = ('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
     + s_var
     + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
print(s)
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxxxbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Правильный стиль для разрывов строк при цепочке методов в Python

PEP 8 рекомендует использовать круглые скобки, чтобы вам не нужно было

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

 my_var = (что-то вроде этого
          .где(мы=делаем_вещи)
          .где(мы=доморе)
          .где(мы=everdomore))

Два соответствующих отрывка из раздела «Максимальная длина строки»:

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

… и весь Должен ли разрываться строка до или после бинарного оператора? раздел:

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

 # Нет: операторы находятся далеко от своих операндов
доход = (валовая_заработная плата +
          налогооблагаемый_процент +
          (дивиденды - квалифицированные_дивиденды) -
          ira_deduction -
          student_loan_interest)

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

»: «Хотя формулы внутри абзаца всегда разрыв после бинарных операций и отношений, отображаемые формулы всегда прерываются перед бинарными операциями»

Следование традиции математики обычно приводит к более читаемый код:

 # Да: легко сопоставить операторы с операндами
доход = (валовая_заработная плата
          + налогооблагаемый_процент
          + (дивиденды - квалифицированные_дивиденды)
          - ira_deduction
          - student_loan_interest)

В коде Python допустимо прерывание до или после двоичного файла. оператора, если соглашение непротиворечиво локально. Для новых предлагается стиль кода Кнута.

Обратите внимание, что, как указано в приведенной выше цитате, PEP 8 использовал , чтобы дать противоположный совет о том, где прерывать работу оператора, приведенный ниже для потомков:

Предпочтительный способ переноса длинных строк — использование подразумеваемой строки Python.

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

 класс Прямоугольник (Blob):
    def __init__(я, ширина, высота,
                 цвет='черный', акцент=нет, подсветка=0):
        если (ширина == 0 и высота == 0 и
            цвет == «красный» и акцент == «сильный» или
            выделить> 100):
            поднять ValueError("извините, вы проиграли")
        если ширина == 0 и высота == 0 и (цвет == 'красный' или
                                           ударение отсутствует):
            поднять ValueError("Я так не думаю -- значения %s, %s" %
                             (ширина высота))
        Blob.
  __init__(я, ширина, высота,
                      цвет, выделение, выделение)

Запись длинной строки в несколько строк в Python

В Python при использовании средств проверки кода PEP8, таких как flake8, возникает ошибка E501 line too long , когда одна строка превышает 80 символов.

В этой статье объясняется, как разделить длинную строку на несколько строк без включения символа новой строки.

Содержимое

  • Символ продолжения строки в Python: обратная косая черта ( \ )
  • Использовать круглые скобки для продолжения строки

См. следующую статью для различных операций, связанных со строками с разрывами строк.

  • Обработка разрывов строк (новых строк) в строках в Python

Если вы хотите переносить или обрезать длинные строки, полезен модуль textwrap.

  • Обтекание и усечение строки с помощью textwrap в Python

Если строка становится слишком длинной из-за цепочки методов, вы можете разбить ее аналогичным образом.

  • Цепочки методов с разрывами строк в Python

Символ продолжения строки в Python: обратная косая черта (

\ )

В Python обратная косая черта ( \ ) является символом продолжения строки. Если в конце строки ставится обратная косая черта, считается, что строка продолжается на следующей строке.

 н = 1 + 2 \
    + 3
печать (н)
№ 6

источник: long_string.py

Кроме того, если несколько строковых литералов записываются последовательно, они объединяются в одну строку следующим образом:

 s = 'aaa' 'bbb'
печать(и)
# аааббб

источник: long_string.py

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

 s = 'https://ja.wikipedia.org/wiki/'\
    '%E3%83%97%E3%83%AD%E3%82%B0%E3%83'\
    '%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E'
печать(и)
# https://ja.wikipedia.org/wiki/%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3% Е3%82%В0%Е8%А8%80%Е8%АА%9Е

источник: long_string. py

Обратите внимание, что только строковые литералы (строки, заключенные в ' или " ) объединяются при последовательной записи. Последовательная запись переменных без оператора вызовет ошибку.

 s_var = 'xxx'
# s = 'ааа' s_var 'bbb'
# SyntaxError: неверный синтаксис

источник: long_string.py

Используйте оператор + для объединения переменных или переменных и строковых литералов.

 с = 'ааа' + s_var + 'bbb'
печать(и)
# аааксхббб

источник: long_string.py

Оператор + требуется для объединения переменных, даже если они разделены обратной косой чертой ( \).

 s = 'аааааааааааааааааааааааааааааааааааааа'\
    + s_var\
    + 'ббббббббббббббббббббббб'
печать(и)
# ааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааааао

источник: long_string. py

Дополнительные сведения о объединении строк см. в следующей статье:

  • Объединение строк в Python (оператор +, соединение и т. д.)

Используйте круглые скобки для продолжения строки

В Python вы можете свободно разрывать строки внутри круглых скобок ( () , {} , [] ). Используя это правило, вы можете разделить длинную строку на несколько строк, используя круглые скобки вместо обратной косой черты.

Поскольку {} используется для наборов, а [] используется для списков, используйте для этой цели () . Обратите внимание, что кортежи создаются запятыми, а не () .

  • Кортеж с одним элементом требует запятой в Python

Можно написать так.

 s = ('https://ja.wikipedia.org/wiki/'
 '%E3%83%97%E3%83%AD%E3%82%B0%E3%83'
 '%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E')
печать(и)
# https://ja.wikipedia.
Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *