Python pep8 на русском: PEP 8 — руководство по написанию кода на Python

PEP 8 — руководство по написанию кода на Python

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

PEP 8 создан на основе рекомендаций Гуидо ван Россума с добавлениями от Барри. Если где-то возникал конфликт, мы выбирали стиль Гуидо. И, конечно, этот PEP может быть неполным (фактически, он, наверное, никогда не будет закончен).

Ключевая идея Гуидо такова: код читается намного больше раз, чем пишется. Собственно, рекомендации о стиле написания кода направлены на то, чтобы улучшить читаемость кода и сделать его согласованным между большим числом проектов. В идеале, весь код будет написан в едином стиле, и любой сможет легко его прочесть.

Это руководство о согласованности и единстве. Согласованность с этим руководством очень важна. Согласованность внутри одного проекта еще важнее. А согласованность внутри модуля или функции — самое важное. Но важно помнить, что иногда это руководство неприменимо, и понимать, когда можно отойти от рекомендаций. Когда вы сомневаетесь, просто посмотрите на другие примеры и решите, какой выглядит лучше.

Две причины для того, чтобы нарушить данные правила:

Внешний вид кода

Отступы

Используйте 4 пробела на каждый уровень отступа.

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

Правильно:

# Выровнено по открывающему разделителю
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

# Больше отступов включено для отличения его от остальных
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

Неправильно:

# Аргументы на первой линии запрещены, если не используется вертикальное выравнивание
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Больше отступов требуется, для отличения его от остальных
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)

Опционально:

# Нет необходимости в большем количестве отступов.
foo = long_function_name(
  var_one, var_two,
  var_three, var_four)

Закрывающие круглые/квадратные/фигурные скобки в многострочных конструкциях могут находиться под первым непробельным символом последней строки списка, например:

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )

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

my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
)

Табуляция или пробелы?

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

Табуляция должна использоваться только для поддержки кода, написанного с отступами с помощью табуляции.

Python 3 запрещает смешивание табуляции и пробелов в отступах.

Python 2 пытается преобразовать табуляцию в пробелы.

Когда вы вызываете интерпретатор Python 2 в командной строке с параметром -t, он выдает предупреждения (warnings) при использовании смешанного стиля в отступах, а запустив интерпретатор с параметром -tt, вы получите в этих местах ошибки (errors). Эти параметры очень рекомендуются!

Максимальная длина строки

Ограничьте длину строки максимум 79 символами.

Для более длинных блоков текста с меньшими структурными ограничениями (строки документации или комментарии), длину строки следует ограничить 72 символами.

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

Некоторые команды предпочитают большую длину строки. Для кода, поддерживающегося исключительно или преимущественно этой группой, в которой могут прийти к согласию по этому вопросу, нормально увеличение длины строки с 80 до 100 символов (фактически увеличивая максимальную длину до 99 символов), при условии, что комментарии и строки документации все еще будут 72 символа.

Стандартная библиотека Python консервативна и требует ограничения длины строки в 79 символов (а строк документации/комментариев в 72).

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

Обратная косая черта все еще может быть использована время от времени. Например, длинная конструкция with не может использовать неявные продолжения, так что обратная косая черта является приемлемой:

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

Ещё один случай — assert.

Сделайте правильные отступы для перенесённой строки. Предпочтительнее вставить перенос строки после логического оператора, но не перед ним. Например:

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)

Пустые строки

Отделяйте функции верхнего уровня и определения классов двумя пустыми строками.

Определения методов внутри класса разделяются одной пустой строкой.

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

Используйте пустые строки в функциях, чтобы указать логические разделы.

Python расценивает символ control+L как незначащий (whitespace), и вы можете использовать его, потому что многие редакторы обрабатывают его как разрыв страницы — таким образом логические части в файле будут на разных страницах. Однако, не все редакторы распознают control+L и могут на его месте отображать другой символ.

Кодировка исходного файла

Кодировка Python должна быть UTF-8 (ASCII в Python 2).

Файлы в ASCII (Python 2) или UTF-8 (Python 3) не должны иметь объявления кодировки.

В стандартной библиотеке, нестандартные кодировки должны использоваться только для целей тестирования, либо когда комментарий или строка документации требует упомянуть имя автора, содержащего не ASCII символы; в остальных случаях использование \x, \u, \U или \N — наиболее предпочтительный способ включить не ASCII символы в строковых литералах.

Начиная с версии python 3.0 в стандартной библиотеке действует следующее соглашение: все идентификаторы обязаны содержать только ASCII символы, и означать английские слова везде, где это возможно (во многих случаях используются сокращения или неанглийские технические термины). Кроме того, строки и комментарии тоже должны содержать лишь ASCII символы. Исключения составляют: (а) test case, тестирующий не-ASCII особенности программы, и (б) имена авторов. Авторы, чьи имена основаны не на латинском алфавите, должны транслитерировать свои имена в латиницу.

Проектам с открытым кодом для широкой аудитории также рекомендуется использовать это соглашение.

Импорты

• Каждый импорт, как правило, должен быть на отдельной строке.

  Правильно:

  import os
  import sys

  Неправильно:

  import sys, os

  В то же время, можно писать так:

  from subprocess import Popen, PIPE

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

  Импорты должны быть сгруппированы в следующем порядке:

  1. импорты из стандартной библиотеки
  2. импорты сторонних библиотек
  3. импорты модулей текущего проекта

  Вставляйте пустую строку между каждой группой импортов.

  Указывайте спецификации __all__ после импортов.

• Рекомендуется абсолютное импортирование, так как оно обычно более читаемо и ведет себя лучше (или, по крайней мере, даёт понятные сообщения об ошибках) если импортируемая система настроена неправильно (например, когда каталог внутри пакета заканчивается на sys.path):

  import mypkg.sibling
  from mypkg import sibling
  from mypkg.sibling import example

  Тем не менее, явный относительный импорт является приемлемой альтернативой абсолютному импорту, особенно при работе со сложными пакетами, где использование абсолютного импорта было бы излишне подробным:

  from . import sibling
  from .sibling import example

  В стандартной библиотеке следует избегать сложной структуры пакетов и всегда использовать абсолютные импорты.

  Неявные относительно импорты никогда не должны быть использованы, и были удалены в Python 3.

• Когда вы импортируете класс из модуля, вполне можно писать вот так:

  from myclass import MyClass
  from foo.bar.yourclass import YourClass

  Если такое написание вызывает конфликт имен, тогда пишите:

  import myclass
  import foo.bar.yourclass

  И используйте «myclass.MyClass» и «foo.bar.yourclass.YourClass».

• Шаблоны импортов (from import *) следует избегать, так как они делают неясным то, какие имена присутствуют в глобальном пространстве имён, что вводит в заблуждение как читателей, так и многие автоматизированные средства. Существует один оправданный пример использования шаблона импорта, который заключается в опубликовании внутреннего интерфейса как часть общественного API (например, переписав реализацию на чистом Python в модуле акселератора (и не будет заранее известно, какие именно функции будут перезаписаны).

Комментарии

Комментарии, противоречащие коду, хуже, чем отсутствие комментариев. Всегда исправляйте комментарии, если меняете код!

Комментарии должны являться законченными предложениями. Если комментарий — фраза или предложение, первое слово должно быть написано с большой буквы, если только это не имя переменной, которая начинается с маленькой буквы (никогда не изменяйте регистр переменной!).

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

Ставьте два пробела после точки в конце предложения.

Программисты, которые не говорят на английском языке, пожалуйста, пишите комментарии на английском, если только вы не уверены на 120%, что ваш код никогда не будут читать люди, не знающие вашего родного языка.

Блоки комментариев

Блок комментариев обычно объясняет код (весь, или только некоторую часть), идущий после блока, и должен иметь тот же отступ, что и сам код. Каждая строчка такого блока должна начинаться с символа # и одного пробела после него (если только сам текст комментария не имеет отступа).

Абзацы внутри блока комментариев разделяются строкой, состоящей из одного символа #.

«Встрочные» комментарии

Старайтесь реже использовать подобные комментарии.

Такой комментарий находится в той же строке, что и инструкция. «Встрочные» комментарии должны отделяться по крайней мере двумя пробелами от инструкции. Они должны начинаться с символа # и одного пробела.

Комментарии в строке с кодом не нужны и только отвлекают от чтения, если они объясняют очевидное. Не пишите вот так:

x = x + 1                 # Increment x

Впрочем, такие комментарии иногда полезны:

x = x + 1                 # Компенсация границы

Строки документации

• Пишите документацию для всех публичных модулей, функций, классов, методов. Строки документации необязательны для приватных методов, но лучше написать, что делает метод. Комментарий нужно писать после строки с def.

• PEP 257 объясняет, как правильно и хорошо документировать. Заметьте, очень важно, чтобы закрывающие кавычки стояли на отдельной строке. А еще лучше, если перед ними будет ещё и пустая строка, например:

  """Return a foobang
  
  Optional plotz says to frobnicate the bizbaz first.
  
  """

• Для однострочной документации можно оставить закрывающие кавычки на той же строке.

Соглашения по именованию

Соглашения по именованию переменных в python немного туманны, поэтому их список никогда не будет полным — тем не менее, ниже мы приводим список рекомендаций, действующих на данный момент. Новые модули и пакеты должны быть написаны согласно этим стандартам, но если в какой-либо уже существующей библиотеке эти правила нарушаются, предпочтительнее писать в едином с ней стиле.

Главный принцип

Имена, которые видны пользователю как часть общественного API должны следовать конвенциям, которые отражают использование, а не реализацию.

Описание: Стили имен

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

Обычно различают следующие стили:

• b (одиночная маленькая буква)
• B (одиночная заглавная буква)
• lowercase (слово в нижнем регистре)
• lower_case_with_underscores (слова из маленьких букв с подчеркиваниями)
• UPPERCASE (заглавные буквы)
• UPPERCASE_WITH_UNDERSCORES (слова из заглавных букв с подчеркиваниями)
• CapitalizedWords (слова с заглавными буквами, или CapWords, или CamelCase). Замечание: когда вы используете аббревиатуры в таком стиле, пишите все буквы аббревиатуры заглавными — HTTPServerError лучше, чем HttpServerError.
• mixedCase (отличается от CapitalizedWords тем, что первое слово начинается с маленькой буквы)
• Capitalized_Words_With_Underscores (слова с заглавными буквами и подчеркиваниями — уродливо!)

Ещё существует стиль, в котором имена, принадлежащие одной логической группе, имеют один короткий префикс. Этот стиль редко используется в python, но мы упоминаем его для полноты. Например, функция os.stat() возвращает кортеж, имена в котором традиционно имеют вид st_mode, st_size, st_mtime и так далее. (Так сделано, чтобы подчеркнуть соответствие этих полей структуре системных вызовов POSIX, что помогает знакомым с ней программистам).

В библиотеке X11 используется префикс Х для всех public-функций. В python этот стиль считается излишним, потому что перед полями и именами методов стоит имя объекта, а перед именами функций стоит имя модуля.

В дополнение к этому, используются следующие специальные формы записи имен с добавлением символа подчеркивания в начало или конец имени:

• _single_leading_underscore: слабый индикатор того, что имя используется для внутренних нужд. Например, from M import * не будет импортировать объекты, чьи имена начинаются с символа подчеркивания.

• single_trailing_underscore_: используется по соглашению для избежания конфликтов с ключевыми словами языка python, например:

  Tkinter.Toplevel(master, class_='ClassName')

• __double_leading_underscore: изменяет имя атрибута класса, то есть в классе FooBar поле __boo становится _FooBar__boo.

• __double_leading_and_trailing_underscore__ (двойное подчеркивание в начале и в конце имени): магические методы или атрибуты, которые находятся в пространствах имен, управляемых пользователем. Например, __init__, __import__ или __file__. Не изобретайте такие имена, используйте их только так, как написано в документации.

Предписания: соглашения по именованию

Имена, которых следует избегать

Никогда не используйте символы l (маленькая латинская буква «эль»), O (заглавная латинская буква «о») или I (заглавная латинская буква «ай») как однобуквенные идентификаторы.

В некоторых шрифтах эти символы неотличимы от цифры один и нуля. Если очень нужно l, пишите вместо неё заглавную L.

Имена модулей и пакетов

Модули должны иметь короткие имена, состоящие из маленьких букв. Можно использовать символы подчеркивания, если это улучшает читабельность. То же самое относится и к именам пакетов, однако в именах пакетов не рекомендуется использовать символ подчёркивания.

Так как имена модулей отображаются в имена файлов, а некоторые файловые системы являются нечувствительными к регистру символов и обрезают длинные имена, очень важно использовать достаточно короткие имена модулей — это не проблема в Unix, но, возможно, код окажется непереносимым в старые версии Windows, Mac, или DOS.

Когда модуль расширения, написанный на С или C++, имеет сопутствующий python-модуль (содержащий интерфейс высокого уровня), С/С++ модуль начинается с символа подчеркивания, например, _socket.

Имена классов

Имена классов должны обычно следовать соглашению CapWords.

Вместо этого могут использоваться соглашения для именования функций, если интерфейс документирован и используется в основном как функции.

Обратите внимание, что существуют отдельные соглашения о встроенных именах: большинство встроенных имен — одно слово (либо два слитно написанных слова), а соглашение CapWords используется только для именования исключений и встроенных констант.

Имена исключений

Так как исключения являются классами, к исключениям применяется стиль именования классов. Однако вы можете добавить Error в конце имени (если, конечно, исключение действительно является ошибкой).

Имена глобальных переменных

Будем надеяться, что глобальные переменные используются только внутри одного модуля. Руководствуйтесь теми же соглашениями, что и для имен функций.

Добавляйте в модули, которые написаны так, чтобы их использовали с помощью from M import *, механизм __all__, чтобы предотвратить экспортирование глобальных переменных. Или же, используйте старое соглашение, добавляя перед именами таких глобальных переменных один символ подчеркивания (которым вы можете обозначить те глобальные переменные, которые используются только внутри модуля).

Имена функций

Имена функций должны состоять из маленьких букв, а слова разделяться символами подчеркивания — это необходимо, чтобы увеличить читабельность.

Стиль mixedCase допускается в тех местах, где уже преобладает такой стиль, для сохранения обратной совместимости.

Аргументы функций и методов

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

Всегда используйте cls в качестве первого аргумента метода класса.

Если имя аргумента конфликтует с зарезервированным ключевым словом python, обычно лучше добавить в конец имени символ подчеркивания, чем исказить написание слова или использовать аббревиатуру. Таким образом, class_ лучше, чем clss. (Возможно, хорошим вариантом будет подобрать синоним).

Имена методов и переменных экземпляров классов

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

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

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

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

Примечание: есть некоторые разногласия по поводу использования __ имена (см. ниже).

Константы

Константы обычно объявляются на уровне модуля и записываются только заглавными буквами, а слова разделяются символами подчеркивания. Например: MAX_OVERFLOW, TOTAL.

Проектирование наследования

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

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

Мы не используем термин «приватный атрибут», потому что на самом деле в python таких не бывает.

Другой тип атрибутов классов принадлежит так называемому API подклассов (в других языках они часто называются protected). Некоторые классы проектируются так, чтобы от них наследовали другие классы, которые расширяют или модифицируют поведение базового класса. Когда вы проектируете такой класс, решите и явно укажите, какие атрибуты являются публичными, какие принадлежат API подклассов, а какие используются только базовым классом.

Теперь сформулируем рекомендации:

• Открытые атрибуты не должны иметь в начале имени символа подчеркивания.

• Если имя открытого атрибута конфликтует с ключевым словом языка, добавьте в конец имени один символ подчеркивания. Это более предпочтительно, чем аббревиатура или искажение написания (однако, у этого правила есть исключение — аргумента, который означает класс, и особенно первый аргумент метода класса (class method) должен иметь имя cls).

• Назовите простые публичные атрибуты понятными именами и не пишите сложные методы доступа и изменения (accessor/mutator, get/set, — прим. перев.) Помните, что в python очень легко добавить их потом, если потребуется. В этом случае используйте свойства (properties), чтобы скрыть функциональную реализацию за синтаксисом доступа к атрибутам.

  Примечание 1: Свойства (properties) работают только в классах нового стиля (в Python 3 все классы являются таковыми).

  Примечание 2: Постарайтесь избавиться от побочных эффектов, связанным с функциональным поведением; впрочем, такие вещи, как кэширование, вполне допустимы.

  Примечание 3: Избегайте использования вычислительно затратных операций, потому что из-за записи с помощью атрибутов создается впечатление, что доступ происходит (относительно) быстро.

• Если вы планируете класс таким образом, чтобы от него наследовались другие классы, но не хотите, чтобы подклассы унаследовали некоторые атрибуты, добавьте в имена два символа подчеркивания в начало, и ни одного — в конец. Механизм изменения имен в python сработает так, что имя класса добавится к имени такого атрибута, что позволит избежать конфликта имен с атрибутами подклассов.

  Примечание 1: Будьте внимательны: если подкласс будет иметь то же имя класса и имя атрибута, то вновь возникнет конфликт имен.

  Примечание 2: Механизм изменения имен может затруднить отладку или работу с __getattr__(), однако он хорошо документирован и легко реализуется вручную.

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

PEP8, правила составления идеального кода для начинающих

PEP 8

Python, подобно живому организму, развивается и приобретает новые возможности благодаря многочисленному международному сообществу согласно определенным правилам и стандартам PEP. PEP – Python Enhancement Proposal, предложения по развитию Python. Эти стандарты позволяют создавать унифицированную проектную документацию для новых утвержденных возможностей языка Python.
Самый известный PEP имеет восьмой порядковый номер. PEP8 содержит перечень принципов написания красивого и лаконичного программного кода на языке Python.

Под названием каждого подраздела главы будет находиться по одному из 19 принципов философии Python (Zen of Python). Попытайтесь «прочувствовать» то, что имел в виду автор. Также, если хочется, вместо русской адаптации этих постулатов, увидеть оригинальный текст Тима Петерса, можно запустив вот такую программу.

import this

Для чего придуман PEP8?

(Читаемость имеет значение)

PEP8 существует, чтобы улучшить “читабельность„ кода. Но почему этот параметр имеет настолько большую важность? Почему написание хорошо читаемого кода – один из фундаментальных принципов языка Python?

Как сказал создатель Python, Гвидо Ван Россум: «Код читается гораздо чаще, чем пишется». Вы можете провести несколько минут, или весь день, в процессе написания куска кода для, к примеру, аутентификации пользователя. Написав его, однажды, вы не будете писать его еще раз. Но вы точно вернетесь, чтобы прочитать его еще и еще раз. Эта часть кода может быть частью проекта, над которым вы работаете. Каждый раз, возвращаясь к этому файлу, придется вспомнить, что этот код делает и почему вы написали это именно так.

Если вы начинающий программист Python, вам может быть тяжело запомнить, что делает определенная часть кода по прошествии нескольких дней после ее написания. Однако, если вы будете следовать рекомендациям PEP8, можете быть уверены, ваш код будет в полном порядке. Вы будете знать, что добавили достаточно пробелов, в соответствии с разделением на логические блоки кода.

Соблюдение PEP8 особенно важно, если вы в поисках вакансии python-разработчика. Чистый и читаемый код показывает высокий профессионализм. Он говорит работодателю о вашем понимании правильного структурирования программного кода.

Если же вы более опытный Python-программист, тогда с помощи PEP8 можно с легкостью объединиться с другими программистами для работы над одной задачей. Хорошо читаемый код имеет в данном случае особую критичность. Люди, ранее не видевшие вас, но знакомые с вашим кодом, будут читать, понимая идею, которую вы хотели донести.

Негласная договоренность об именах

(Явное лучше, чем неявное)

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

Не использовать одиночные буквы l, O, или I в качестве каких‑либо имен из‑за риска спутать их с 1 и 0, в зависимости от шрифта.

O = 2  # Это может выглядеть так, будто вы хотите приравнять 2 к нулю.

Стили именования

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

Помимо выбора правильных стилей именования в вашем коде, вы также должны тщательно выбирать сами имена. Ниже приведены несколько советов, как сделать это максимально эффективно.

Правильный выбор имени

Выбор имен для переменных, функций, классов и т. д. может оказаться неожиданно сложной задачей. При написании кода вы должны хорошо продумать свой выбор имен, так как это сделает ваш код более читаемым. Лучший способ назвать ваши объекты в Python — использовать описательные имена, чтобы было понятно, что представляет собой объект.

При именовании переменных у вас может возникнуть соблазн выбрать простые, состоящие из одной буквы имена в нижнем регистре, например x. Но если вы не используете x в качестве аргумента математической функции, непонятно, что представляет собой этот самый x. Представьте, что вы храните имя человека в виде строки и хотите использовать срез строки, чтобы по‑другому отформатировать его имя.

Вы можете получить что‑то вроде этого:

# Не рекомендуется
x = 'Иван Петров'
y, z = x.split()

Это будет работать, но вам нужно будет отслеживать, что представляют собой x, y и z. Это также может сбивать с толку соавторов. Более правильный выбор имен будет примерно таким:

# Рекомендуется
name = 'Иван Петров'
first_name, last_name = name.split()

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

# Не рекомендуется
def db(x):
    return x * 2

На первый взгляд, это может показаться очевидным выбором — это ведь отличное сокращением для double! Но представьте, что вернетесь к этому коду через несколько дней. Скорее всего, вы забудете, какой смысл вкладывали в эту функцию и вполне можете подумать, что это сокращение от database.

Следующий пример еще более понятен:

# Рекомендуется
def multiply_by_two(x):
    return x * 2

Та же самая философия относится и ко всем прочим типам данных и объектов в Python. Всегда пробуйте использовать наиболее емкие и лаконичные названия.

Расположение кода

(Красивое лучше, чем уродливое)

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

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

Окружите функции и классы верхнего уровня двумя пустыми строками. Функции и классы верхнего уровня должны быть самодостаточны и обрабатывать отдельные функции. Имеет смысл разместить вокруг них дополнительное вертикальное пространство, чтобы было ясно, что они разделены:

class MyFirstClass:
    pass


class MySecondClass:
    pass


def top_level_function():
    return None

Обособьте определения методов внутри классов одной пустой строкой. Внутри класса все функции связаны друг с другом. Рекомендуется оставлять между ними только одну строку:

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

Используйте пустые строки внутри функций, чтобы четко показать шаги. Иногда сложная функция должна выполнить несколько шагов перед оператором return. Чтобы помочь читателю понять логику внутри функции, может быть полезно оставлять пустую строку между каждым шагом.

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

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

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

Максимальная длина строки и разрыв строки

PEP8 предлагает ограничить длину строки 79 символами. Это рекомендуется делать, чтобы вы имели возможность открывать несколько файлов рядом друг с другом, а также избегать переноса строк.

Конечно, не всегда возможно обеспечить длины всех операторов до 79 символов. PEP8 также описывает способы, позволяющие операторам занимать несколько строк. Python предполагает наличие продолжения строки, если код заключен в круглые, квадратные или фигурные скобки:

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one 

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

from mypkg import example1, \
    example2, example3

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

Отступы

(Должен быть один очевидный способ сделать это)

Отступы или же пробелы в начале строки — крайне важная часть в синтаксисе Python. Как группируются операторы друг с другом операторы, в Python определяют именно уровни строк.

x = 2
if x > 6:
    print('x больше, чем 6')

Отступ перед оператором вывода дает сигнал Python об условном выполнении только в случае, когда оператор if возвращает True. Ровно такой же отступ покажет Python, какой именно код выполнять при вызове функции или какой код имеет отношение к данному классу.
Ключевых правил расстановки отступов всего два и они ниже:

1. Используйте четыре последовательных пробела для отступа;

2. Отдавайте предпочтение пробелам, а не табуляции.

Пробелы против Табуляции

Вы можете настроить ваш редактор кода на вставку четырех пробелов, когда вы нажимаете клавишу Tab.
Также необходимо иметь в виду, что в Python 3 запрещено смешение пробелов и табуляции. Изначально выберите, как именно вы будете выставлять отступы и придерживайтесь этого выбора. Иначе, вместо выполнения кода, вы получите ошибку.

Комментарии

(Если реализацию трудно объяснить, это была плохая идея)

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

1. Используйте длину комментариев при документации не более 72 символов;

2. Не используйте сокращения, начинайте предложения с заглавной буквы;

3. Не забывайте актуализировать комментарии, при изменении кода.

Пример простейшего комментария:

name = 'John Smith'  # Student Name

Пробелы в выражениях и утверждениях

(Разреженное лучше, чем плотное)

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

Окружите следующие бинарные операторы одним пробелом с каждой стороны:

1. Операторы присвоения ( =, +=, -= и т. п.)

2. Сравнения ( ==, !=, >, <. >=, <= ) и (is, is not, in, not in)

3. Логические (and, or, not)

Когда = используется для присвоения значения для аргумента функции, не окружайте его пробелами.

Рекомендации программисту

(Простое лучше сложного)

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

# Не рекомендуется
my_bool = 4 > 3
if my_bool == True:
    return '4 больше 3'

Использование оператора эквивалентности здесь не имеет необходимости, my_bool может иметь только два значения, True или False. Поэтому достаточно написать так:

# Рекомендуется
if my_bool:
    return '4 is bigger than 3'

Этот способ выполнения оператора if с логическим оператором проще и требует меньше кода, поэтому PEP8 рекомендует именно его.

Когда лучше проигнорировать PEP8

Однозначно ответить на этот вопрос довольно сложно. Если вы безукоризненно исполняете все предписания PEP8, можно с уверенностью гарантировать «чистоту», высокий уровень читаемости кода и профессионализм программиста. Что принесет пользу всем взаимодействующим с вашим кодом, от коллег до конечного заказчика продукта.
Но все же некоторые рекомендации PEP8 неприменимы в следующих случаях:

1. Если соблюдение PEP8 нарушит совместимость с существующим программным обеспечением;

2. Если код, сопутствующий тому, над чем вы работаете, несовместим с PEP8;

3. Если код нужно оставить совместимым с неактуальными версиями Python.

Заключение

Теперь вам должно стать понятны способы создания высококачественного, читаемого кода Python, с помощью рекомендаций PEP8. Хотя они могут показаться тюрьмой для мозга творца, их соблюдение действительно может «прокачать» ваш код, в частности, когда речь заходит о разделении работы над ним с соавторами.

Если же у вас имеется желание углубиться в изучение тонкостей PEP8, можно ознакомиться с полной англоязычной документацией или посетить информационный ресурс pep8.org, содержащий ту же информацию, в более структурированном виде. В этих документах вы найдете, не попавшие в эту «выжимку», рекомендации.

Правила оформления кода по PEP8 на Python. Руководство для программиста — Python 3 | Data Science | Нейронные сети | AI

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

Вы также можете использовать это для замены переменных:

В Python 3 новый метод расширенной распаковки был представлен PEP3132 :

Если вам нужно что-то назначить (например, в распаковке ), но вам не понадобится эта переменная, используйте __:

Поскольку списки являются изменяемыми, *оператор (как указано выше) создаст список из N ссылок на один и тот же список, что вряд ли вам нужно. Вместо этого используйте понимание списка:

Примечание: используйте range () вместо xrange () в Python 3.

Распространенная идиома для создания строк — использовать str.join()пустую строку.

Это установит значение переменной word в «spam». Эта идиома может применяться к спискам и кортежам.

Поиск предмета в коллекции 

Иногда нам нужно искать в коллекции вещей. Давайте рассмотрим два варианта: списки и наборы.

Возьмите следующий код для примера:

s = set(['s', 'p', 'a', 'm'])
l = ['s', 'p', 'a', 'm']

def lookup_set(s):
    return 's' in s

def lookup_list(l):
    return 's' in l

Хотя обе функции выглядят одинаково, поскольку lookup_set использует тот факт, что наборы в Python являются хеш-таблицами, производительность поиска между ними очень различна. Чтобы определить, есть ли элемент в списке, Python должен будет просмотреть каждый элемент, пока не найдет соответствующий элемент. Это отнимает много времени, особенно для длинных списков. В наборе, с другой стороны, хеш элемента сообщит Python, где в наборе искать соответствующий элемент. В результате поиск может быть выполнен быстро, даже если набор большой. Поиск в словарях работает так же. Для получения дополнительной информации см. Эту страницу StackOverflow . Для получения подробной информации о времени, которое различные общие операции выполняют для каждой из этих структур данных, см. Эту страницу .

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

• Коллекция будет содержать большое количество предметов
• Вы будете неоднократно искать предметы в коллекции
• У вас нет дубликатов.

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

Дзен питона 

Также известен как PEP 20 , руководящие принципы для дизайна Python.

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Некоторые примеры хорошего стиля Python см. На этих слайдах из группы пользователей Python .

Соглашения PEP8

Вот некоторые соглашения, которым вы должны следовать, чтобы сделать ваш код легче для чтения.

Проверьте, равна ли переменная постоянной 

Вам не нужно явно сравнивать значение с True, None или 0 — вы можете просто добавить его в оператор if. См. Проверка истинности значения для получения списка того, что считается ложным.

Плохо :

if attr == True:
    print 'True!'

if attr == None:
    print 'attr is None!'

Хорошо :

# Just check the value
if attr:
    print 'attr is truthy!'

# or check for the opposite
if not attr:
    print 'attr is falsey!'

# or, since None is considered false, explicitly check for it
if attr is None:
    print 'attr is None!

Доступ к элементу словаря 

Не используйте dict.has_key()метод. Вместо этого используйте синтаксис или передайте аргумент по умолчанию для .x in ddict.get()

Плохо :

d = {'hello': 'world'}
if d.has_key('hello'):
    print d['hello']    # prints 'world'
else:
    print 'default_value'

Хорошо :

d = {'hello': 'world'}

print d.get('hello', 'default_value') # prints 'world'
print d.get('thingy', 'default_value') # prints 'default_value'

# Or:
if 'hello' in d:
    print d['hello']

Короткие способы манипулирования списками 

Постижения списков предоставляют мощный и лаконичный способ работы со списками.

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

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

Плохо :

# needlessly allocates a list of all (gpa, name) entires in memory
valedictorian = max([(student.gpa, student.name) for student in graduates])

Хорошо :

valedictorian = max((student.gpa, student.name) for student in graduates)

Используйте списки, когда вам действительно нужно создать второй список, например, если вам нужно использовать результат несколько раз.

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

Хорошо :

def make_batches(items, batch_size):
    """
    >>> list(make_batches([1, 2, 3, 4, 5], batch_size=3))
    [[1, 2, 3], [4, 5]]
    """
    current_batch = []
    for item in items:
        current_batch.append(item)
        if len(current_batch) == batch_size:
            yield current_batch
            current_batch = []
    yield current_batch

Никогда не используйте списочное понимание только для его побочных эффектов.

Плохо :

[print(x) for x in sequence]

Хорошо :

for x in sequence:
    print(x)

Фильтрация списка 

Плохо :

Никогда не удаляйте элементы из списка, пока вы просматриваете его.

# Filter elements greater than 4
a = [3, 4, 5]
for i in a:
    if i > 4:
        a.remove(i)

Не делайте несколько проходов по списку.

while i in a:
    a.remove(i)

Хорошо :

Используйте понимание списка или выражение генератора.

# comprehensions create a new list object
filtered_values = [value for value in sequence if value != x]

# generators don't create another list
filtered_values = (value for value in sequence if value != x)

Возможные побочные эффекты изменения исходного списка 

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

# replace the contents of the original list
sequence[::] = [value for value in sequence if value != x]

Изменение значений в списке 

Плохо :

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

# Add three to all list members.
a = [3, 4, 5]
b = a                     # a and b refer to the same list object

for i in range(len(a)):
    a[i] += 3             # b[i] also changes

Хорошо :

Безопаснее создать новый объект списка и оставить оригинал в покое.

a = [3, 4, 5]
b = a

# assign the variable "a" to a new list without changing "b"
a = [i + 3 for i in a]

Используйте enumerate()счетчик вашего места в списке.

a = [3, 4, 5]
for i, item in enumerate(a):
    print i, item
# prints
# 0 3
# 1 4
# 2 5

enumerate()Функция имеет лучшую читаемость , чем обработка счетчика вручную. Более того, он лучше оптимизирован для итераторов.

Читать из файла 

Используйте синтаксис для чтения из файлов. Это автоматически закроет файлы для вас.with open

Плохо :

f = open('file.txt')
a = f.read()
print a
f.close()

Хорошо :

with open('file.txt') as f:
    for line in f:
        print line

Это withутверждение лучше, потому что оно гарантирует, что вы всегда закроете файл, даже если внутри withблока возникнет исключение .

Продолжение строки 

Когда логическая строка кода длиннее допустимого предела, вам необходимо разбить ее на несколько физических строк. Интерпретатор Python объединяет последовательные строки, если последний символ строки является обратной косой чертой. Это полезно в некоторых случаях, но, как правило, его следует избегать из-за его хрупкости: пробел, добавленный в конец строки после обратной косой черты, нарушит код и может привести к неожиданным результатам.

Лучшее решение — использовать круглые скобки вокруг ваших элементов. Оставленный с незакрытой круглой скобкой в ​​конце строки, интерпретатор Python присоединится к следующей строке, пока круглые скобки не будут закрыты. То же самое относится и к фигурным и квадратным скобкам.

Плохо :

my_very_big_string = """For a long time I used to go to bed early. Sometimes, \
    when I had put out my candle, my eyes would close so quickly that I had not even \
    time to say “I’m going to sleep.”"""

from some.deep.module.inside.a.module import a_nice_function, another_nice_function, \
    yet_another_nice_function

Хорошо :

my_very_big_string = (
    "For a long time I used to go to bed early. Sometimes, "
    "when I had put out my candle, my eyes would close so quickly "
    "that I had not even time to say “I’m going to sleep.”"
)

from some.deep.module.inside.a.module import (
    a_nice_function, another_nice_function, yet_another_nice_function)

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

PEP8 коротко и по-русски

18 Oct 2008, 18:34,

python

PEP8 — это стилевые правила для кода на языке Python.

• используйте 4 пробела для отступа и не используйте табы, не смешивайте их
• максимальная длина строки 79 символов; для разрыва строки используйте отступы или бэкслеш
• функции верхнего уровня и определения классов отделяйте двумя пустыми строками
• определения методов внутри класса отделяйте одной пустой строкой
• дополнительные пустые строки используйте для логической группировки методов
• кодировка файлов должна быть Latin-1, а в Питоне 3 и выше — utf-8
• каждый импортируемый модуль с новой строки
• порядок импортов: стандартные модули, third-party модули, локальные модули приложения
• пустая строка между каждой группой импортов
• избегайте лишних пробелов внутри скобок; перед запятыми, точкой с запятой и двоеточиями
• избегайте лишних пробелов перед скобками с аргументами функций и скобками с индексами
• избегайте больше чем одного пробела между операторами (= — + итд)
• используйте одиночный пробел для выделения операторов
• избегайте пробелов вокруг ‘=’, который используется для параметров по-умолчанию и keyword аргументов
• обновляйте комментарии вместе с кодом
• пишите комментарии по-английски
• избегайте имён из одиночных l, O, I
• для модулей и пакетов используйте короткие всестрочные имена
• для классов используйте СловаНачинаютсяЗаглавными имена
• для функций используйте слова_с_подчёркиваниями (или смешанныйРегистр если так получилось исторически)
• для методов используйте слова_с_подчёркиваниями имена
• для внутренних методов и переменных _подчёркивание_перед_словом
• для проверки на None используйте is или is not, не используйте операторы сравнения
• используйте исключения основанные на классах – наследованные от Exception
• используйте методы класса string вместо строковых функций
• используйте ‘‘.startswith() и ‘‘.endswith() вместо вырезки из строк для проверки префиксов и суффиксов
• используйте isinstance() для проверки типа
• не сравнивайте булевы переменные с True и False

Форматирование Python-кода / Хабр

Введение

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

хорошая

. А вот скорость разработки и читаемости отличная.

О читаемости и пойдет речь, а точнее как ее увеличить.

Проблемы форматирования

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

Для python’а основными проблемами форматирования является «C стиль». Не редко в рассматриваемый язык приходят из С-подобных языков, а для них свойственно писать с символами «)(;».

Символы не единственная проблема, есть еще и проблема избыточности написания конструкций. Питон, в отличие от Java, менее многословен и чтобы к этому привыкнуть у новичков уходит большое количество времени.

Это две основные проблемы, которые встречаются чаще всего.

Стандарты и рекомендации к оформлению

Если для повышения скорости исполнения кода можно использовать

разные подходы

, хотя эти подходы очень индивидуальны, то для форматирования текста существует прям slyle guide — это pep8. Далее его буду называть «стандарт».

Почитать про стандарт можно

здесь

, на русском языке можно

здесь

Pep8 весьма обширный и позволяет программисту писать РЕАЛЬНО читаемый код.

Он включает:

• максимальную длину строк кода и документации
• кодировки файлов с исходным кодом
• рекомендации как правильно оформлять комментарии
• соглашения именования функций/классов, аргументов
• и многое другое

В целом, покрывает множество правил форматирования кода. Однако, стоит заметить, что не все python-программисты соблюдают данные правила.

Большие компании, такие как Google, имеют свои рекомендации к написанию python-кода, их можно почитать

здесь

и

здесь

.

Весьма интересное чтиво, рекомендую.

Автоматизируем форматирование

Если посмотреть сколько всяких правил в pep8, то можно сесть за рефакторинг надолго. Вот только это лениво, да и при написании нового кода сиравно будут какие-то ошибки правил. Для этого рассмотрим как же себе можно упростить жизнь.

pep8

Дабы иметь представление сколько ошибок оформления в коде, стоит использовать утилиту

pep8

.

У нее достаточный список параметров, который позволяет рекурсивно просмотреть все файлы в папках на предмет соответствия стандарту pep8.

Вывод утилиты примерно такой:

$ pep8 --first optparse.py
optparse.py:69:11: E401 multiple imports on one line
optparse.py:77:1: E302 expected 2 blank lines, found 1
optparse.py:88:5: E301 expected 1 blank line, found 0
optparse.py:222:34: W602 deprecated form of raising exception
optparse.py:347:31: E211 whitespace before '('
optparse.py:357:17: E201 whitespace after '{'
optparse.py:472:29: E221 multiple spaces before operator
optparse.py:544:21: W601 .has_key() is deprecated, use 'in'

По нему можно однозначно понять: где ошибка и что случилось.

autopep8

Ошибки стандарта часто повторяются от файла в файлу. И возникает сильное желание исправление автоматизировать. В этом случае на арену выходит

autopep8

.

Как и pep8, он умеет самостоятельно определять ошибки, а также исправлять их. Список исправляемых ошибок форматирования можно найти

здесь

Само использование autopep8 крайне простое и может выглядеть так:

$ autopep8 ./ --recursive --in-place -a

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

autoflake

Можно пойти дальше и в качестве оружия взять

autoflake

. Эта утилита помогает удалить не используемые импорты и переменные.

Используется примерно так:

$ autoflake --in-place --remove-all-unused-imports --remove-unused-variables -r ./

Тем самым будут рекурсивно почищены файлы в директории.

unify

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

unify

Использование:

$ unify --in-place -r ./src/

Как и везде, утилита выполнит свое грязное дело рекурсивно для файлов в папке.

docformatter

Все время говорим о самом коде, а о комментариях еще ни разу не шло речи. Настало время —

docformatter

. Эта утилита помогает привести ваши docstring по соглашению

PEP 257

. Соглашение предписывает как следует оформлять документацию.

Использование утилиты ничуть не сложнее предыдущих:

$ docformatter --in-place example.py

А все вместе можно?

Выше описаны утилиты, их запуск можно добавить какой-нибудь bash скрипт под магическим названием clean.bash и запускать. А можно пойти и по другому пути и использовать wrapper над этими утилитами —

pyformat

Выводы

Python-код легко читается, однако, есть способы сделать лапшу и из читаемого кода.

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

Стоит озвучить вслух следующую рекомендацию при написании кода, которая универсальна для любого языка: более важным правилом оформлением, чем подобные pep8-документы — это постоянство стиля. Выбрали в каком стиле будете писать программу, в этом же и пишите весь код.

Если читателям будет интересно, то в следующей статье я опишу как в автоматическом режиме искать ошибки в коде.

Python: русский PEP8 (сокращенная версия)

Краткое изложение стандартов оформления кода на Python, известное, как PEP8. Стандарт служит для удобства чтения вашего кода другими разработчиками. Начинающим разработчикам на Python рекомендуется распечатать и повесить на стену.

• используйте 4 пробела для отступа и не используйте табы, не смешивайте их
• максимальная длина строки 79 символов; для разрыва строки используйте отступы или бэкслеш
• функции верхнего уровня и определения классов отделяйте двумя пустыми строками
• определения методов внутри класса отделяйте одной пустой строкой
• дополнительные пустые строки используйте для логической группировки методов
• кодировка файлов должна быть Latin-1, а в Питоне 3 и выше — utf-8
• каждый импортируемый модуль с новой строки
• порядок импортов: стандартные модули, third-party модули, локальные модули приложения
• пустая строка между каждой группой импортов
• избегайте лишних пробелов внутри скобок; перед запятыми, точкой с запятой и двоеточиями
• избегайте лишних пробелов перед скобками с аргументами функций и скобками с индексами
• избегайте больше чем одного пробела между операторами (= — + итд)
• используйте одиночный пробел для выделения операторов
• избегайте пробелов вокруг ‘=’, который используется для параметров по-умолчанию и keyword аргументов
• обновляйте комментарии вместе с кодом
• пишите комментарии по-английски
• избегайте имён из одиночных l, O, I
• для модулей и пакетов используйте короткие всестрочные имена
• для классов используйте СловаНачинаютсяЗаглавными имена
• для функций используйте слова_с_подчёркиваниями (или смешанныйРегистр если так получилось исторически)
• для методов используйте слова_с_подчёркиваниями имена
• для внутренних методов и переменных _подчёркивание_перед_словом
• для проверки на None используйте is или is not, не используйте операторы сравнения
• используйте исключения основанные на классах — наследованные от Exception
• используйте методы класса string вместо строковых функций
• используйте ».startswith() и ».endswith() вместо вырезки из строк для проверки префиксов и суффиксов
• используйте isinstance() для проверки типа
• не сравнивайте булевы переменные с True и False

Поделиться «Python: русский PEP8 (сокращенная версия)»

Интересное по теме:

PEP8 — стиль кода в языке Python

Стиль кода в языке python

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

Подробнее

Code Conventions. (for the Java Programming Language)

Code Conventions (for the Java Programming Language) Зачем? 80% времени жизни ПО находится в поддержке Почти никогда ПО не поддерживается автором Соглашение об именовании улучшает читаемость кода, ускоряя

Подробнее

Предисловие От издательства…14

Оглавление Предисловие… 13 От издательства…14 Глава 1. Почему Python?…15 Глава 2. Какая версия Python?…17 2.1. Установка Python…17 2.2. Какой редактор?…19 2.3. Итоги… 19 2.4. Упражнения…

Подробнее

Primes = [2, 3, 5, 7, 11, 13] Rainbow = [‘Red’, ‘Orange’, ‘Yellow’, ‘Green’, ‘Blue’, ‘Indigo’, ‘Violet’]

Списки Большинство программ работает не с отдельными переменными, а с набором переменных. Например, программа может обрабатывать информацию об учащихся класса, считывая список учащихся с клавиатуры, при

Подробнее

Язык программирования Си

Язык программирования Си Алфавит языка Си прописные и строчные буквы латинского алфавита A,…, Z, a,…, z цифры 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 специальные знаки, {} [] () + — / % \ ;. 😕 < = > _! & * #

Подробнее

Основные элементы языка

Основные элементы языка Язык Pascal (Паскаль), изобретенный в начале 70-х годов 20-го века Н. Виртом и названный в честь французского математика и философа Блеза Паскаля, является одним из наиболее распространенных

Подробнее

YART Studio. Язык программирования C-YART

YART Studio Язык программирования C-YART Санкт-Петербург 2018 Оглавление C-YART… 3 Типы данных… 3 Комментарии к коду… 3 Структура кода… 3 Переменные, константы и массивы… 4 Математические операторы…

Подробнее

Правила оформления программ

Правила оформления программ Этот список правил поможет вам оформлять свои программы красиво и правильно. За несоблюдение данных правил решение может не засчитываться и получать статус «Отклонено» или «Нарушение

Подробнее

Лекция 3 Текстовый процессор

Лекция 3 Текстовый процессор Текстовый редактор Microsoft Word Приложение Microsoft Word 2010 это текстовый процессор, предназначенный для создания профессионально оформленных документов. Объединяя в себе

Подробнее

Программирование PYTHON. Урок 1

Программирование PYTHON Урок 1 2 Темы урока Основы программирования Python Введение. Установка и тестирование среды разработки Python Переменные и выражения. Типы данных Оператор вывода Арифметика на языке

Подробнее

Содержание. Часть I. Основы Java 21

Содержание Об авторе 13 Введение 15 Как работать с этой книгой 15 Соглашения, используемые в книге 15 Что можно не читать 16 Несколько предположений 17 Структура книги 18 Часть I. Основы Java 18 Часть

Подробнее

Алфавит. Алфавит языка PASCAL

Алфавит языка PASCAL Текст PASCAL-программы представляет собой последовательность строк, состоящих из символов, образующих алфавит языка. Максимальная длина строки — 126 символов. Алфавит Буквы Цифры Управляющ.

Подробнее

ÀÑÒÜ I. ÏÅÐÂÎÅ ÇÍÀÊÎÌÑÒÂÎ Ñ C++

Ñîäåðæàíèå Введение 16 О чем эта книга 16 Прилагаемый компакт-диск 16 Что такое C++ 17 Соглашения, используемые в книге 17 Как организована эта книга 18 И еще… 18 Часть I. Первое знакомство с C++ 18

Подробнее

Python 3. Краткое введение

Python 3 Краткое введение Хамовники, 2011 Язык Python Python мощный и простой для изучения язык программирования. Интерпретатор Python и разрастающаяся стандартная библиотека находятся в свободном доступе

Подробнее

Основы программирования на языке Python

Основы программирования на языке Python Основные типы данных 2 Основные числовые операции 3 Основные логические операции 4 Основные функции 5 Инструкция ветвления 7 Циклы 8 Функции 10 Списки 11 Основные

Подробнее

«УВЛЕКАТЕЛЬНАЯ ИНФОРМАТИКА»

ДЕПАРТАМЕНТ ОБРАЗОВАНИЯ ГОРОДА МОСКВЫ Государственное бюджетное общеобразовательное учреждение города Москвы «Школа 2000» (ГБОУ Школа 2000) Принята на заседании педагогического совета Протокол от «30»

Подробнее

Операции и выражения

Глава 5 Операции и выражения В этой главе Выражения в языке VBA Совместимость типов данных Оператор присваивания Арифметические операторы Логические операторы Операторы сравнения Строковые операторы Приоритеты

Подробнее

Элементы языка Паскаль и типы данных Операции, функции выражения Оператор присваивания, ввод и вывод данных

Элементы языка Паскаль и типы данных Операции, функции выражения Оператор присваивания, ввод и вывод данных Алфавит языка Латинские буквы: от A до Z и от а до z Цифры: 0,1,2,3,4,5,6,7,8,9 Специальные символы:

Подробнее

Урок 3. Основы программирования

Урок 3. Основы программирования О чем урок: знакомство с javascript переменные типы данных ветвления функции практика Смотреть урок: [marafon_03.mp4] JavaScript Теперь, после того как в первых двух уроках

Подробнее

Введение в программирование

Введение в программирование Алексей Гуревич, СПбАУ РАН [email protected] План 1. Введение 2. Установка Python 3. Переменные, типы данных 4. Операторы 5. Ввод-вывод 6. Функции 7. Модули 8. Вызов внешних

Подробнее

Управляющие конструкции

Управляющие конструкции if Конструкция if предоставляет возможность условного выполнения фрагментов кода. if (выражение) инструкция Выражение вычисляется в булево значение. Если выражение принимает значение

Подробнее

Программа язык Паскаль (Н. Вирт)

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

Подробнее

Программирование на Python

Программирование на Python Занятие 1. Переменные и операции. Условия Павел Федотов [email protected] Работа в интерактивном режиме python3 Пробуем любые команды Видим результат exit() выход Ctrl + D выход

Подробнее

Операционная система Linux. Лекция 10

Операционная система Linux Лекция 10 Язык обработки данных AWK AWK (читается «оук») — интерпретируемый скриптовый C-подобный язык построчного разбора и обработки входного потока (например, текстового файла)

Подробнее

Часть I. Подготовка инструментов 21

Об авторе 13 Введение 14 Об этой книге 14 Как пользоваться книгой 14 Соглашения, принятые в книге 15 Что можно не читать 15 Ряд предположений 16 Структура книги 17 Часть I. Подготовка инструментов 17 Часть

Подробнее

Операторы в JAVA. Лекция 4

Лекция 4 Операторы в JAVA Ввод информации с клавиатуры Проще всего вводить числа с клавиатуры, пользуясь классом Scanner. Этот класс принадлежит пакету java.util. Следовательно, чтобы использовать его

Подробнее

C++ Code Style Guide

C++ Code Style Guide Что такое Style Guide?!»# $%&'( )*’$+»,( -.#/ )*0.’1 # «#2: &0& #3#*21+»4 &#/ &0& ‘2%$#.0″4 )%*%2%$$,%, &10—,, 30(1,… &0& &#22%$»‘*#.0″4 &#/ ‘ 2$#5#% /*65#% Зачем он нужен? 71+

Подробнее

Описание образовательной программы

Описание образовательной программы Настоящая образовательная программа повышения квалификации (далее Программа) разработана в соответствии с: 1. Федеральным законом от 29 декабря 2012 г. N 273-ФЗ «Об образовании

Подробнее

О СНОВНЫЕ ПОНЯТИЯ ЯЗЫКА П АСКАЛЬ

О СНОВНЫЕ ПОНЯТИЯ ЯЗЫКА П АСКАЛЬ Программа на языке Паскаль формируется с помощью конечного набора знаков, образующих алфавит языка, и состоит из букв, цифр, специальных символов. В качестве букв используются

Подробнее

program LAB1 read (*, *) x res=(2*x**2 + 3.)*sin (x) + exp (x**3 + 1.)

Лабораторная работа 1 Разработка простейших программ Общие сведения Для выполнения лабораторной работы необходимо изучить теоретический материал по следующим разделам: 1. базовые конструкции языка Фортран

Подробнее

Глухих Михаил Игоревич mailto:

Глухих Михаил Игоревич mailto: [email protected] Последовательность действий (обычно записанная формально), необходимая для решения определённой задачи 2 Запись алгоритма на языке программирования (или

Подробнее

Глухих Михаил Игоревич mailto:

Глухих Михаил Игоревич mailto: [email protected] 2 Норма: настроили Идею, сделали и отправили в Котоед часть или все задачи первого урока 3 Норма: настроили Идею, сделали и отправили в Котоед часть или

Подробнее

МНОЖЕСТВА В ТУРБО-ПАСКАЛЕ

Федеральное агентство по образованию Государственное образовательное учреждение высшего профессионального образования Донской государственный технический университет Кафедра «Программное обеспечение вычислительной

Подробнее

Пользовательский формат числа в Excel

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

Подробнее

Введение в Python и Eric

Введение в Python и Eric Иван Хахаев, 2009 Строки и последовательности В главе «Простой ввод и вывод» мы уже имели дело со строками (данными символьного типа). Теперь рассмотрим работу со строками в Python

Подробнее

Тема 9. Типы. Структурированные типы.

Тема 9. Типы. Структурированные типы. В Object Pascal четыре структурированных типа: массивы, записи, множества и файлы. Любой из структурированных типов характеризуется множественностью образующих этот

Подробнее

20 Юникод Историческая справка

20 Юникод Строки уже неоднократно встречались вам в этой книге, но мы еще не обсуждали одно из самых больших изменений Python 3 строки Юникода. В Python 2 строки Юникода поддерживались, но их нужно было

Подробнее

Базовые конструкции и типы в Haskell

Базовые конструкции и типы в Haskell Михаил Беляев 18 сентября 2018 г. 1/44 Синтаксис языка: функции Обычная функция: имя это стандартный идентификатор foo :: Integer -> Integer foo x = x + 2 Можно использовать

Подробнее

Импорт данных в CREDO_DAT

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

Подробнее

Изм. 1 от С. 1 из 5

С. 1 из 5 ПАМЯТКА 1. Сверстанный текст должен: быть максимально похож на оригинал; быть в редактируемом и доступном формате (на данный момент MS Word 2007), если не требуется иное. 2. Сверстанный текст

Подробнее

Введение. Язык программирования Python

Введение. Язык программирования Python В рамках данного курса мы будем изучать программирование на примере современного языка программирования Python 3. Его основные достоинства: 1. Кроссплатформенность

Подробнее

PEP 545 — Перевод документации Python

Доменное имя, согласование содержимого и URL-адрес

Различные переводы можно определить, изменив один из
следующее: Код страны Домен верхнего уровня (CCTLD),
сегмент пути, поддомен или согласование содержимого.

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

Использование субдоменов, таких как «es.docs.python.org «или» docs.es.python.org «- это
возможно, но сбивает с толку («это es.docs.python.org или
docs.es.python.org ? «). Дефисы в субдоменах, например
pt-br.doc.python.org встречается редко, и SEOMoz коррелирует
наличие дефисов как негативный фактор. Использование подчеркивания в
поддомен запрещен RFC1123, раздел 2.1. Наконец-то,
использование поддоменов означает создание сертификатов TLS для каждого
язык. Это не только требует большего обслуживания, но также вызовет
проблемы в переключателе языков, если, что касается переключателя версий, мы хотим
предполет, чтобы проверить, существует ли перевод в данной версии:
предварительная проверка, вероятно, будет заблокирована политикой того же происхождения.Подстановочный знак
Сертификаты TLS очень дороги.

Использование согласования содержимого (HTTP-заголовки Accept-Language в
request and Vary: Accept-Language) приводит к плохому взаимодействию с пользователем
где они не могут легко изменить язык. Согласно Mozilla:
«Этот заголовок является подсказкой, которую следует использовать, когда сервер не может
определение языка другим способом, например, с помощью определенного URL-адреса, т. е.
контролируется явным решением пользователя «. Как мы и хотим,
может легко изменить язык, мы не должны использовать контент
переговоры как определение основного языка, поэтому нам нужно что-то
еще.

Последнее решение — использовать URL-путь, который выглядит читабельным, позволяет
для легкого переключения с одного языка на другой и прекрасно принимает
дефисы. Обычно что-то вроде: «docs.python.org/de/» или
используя дефис: «docs.python.org/pt-BR/».

Что касается версии, sphinx-doc не поддерживает компиляцию для нескольких
языков, поэтому у нас будут полные сборки с корнем, точно так же, как
мы уже занимаемся версиями.

Итак, мы можем иметь «docs.python.org/de/3.6/» или
«документы.python.org/3.6/de/ «. Возникает вопрос:
«Есть ли в языке несколько версий или версия содержит
несколько языков? «. Так как версии существуют в любом случае и переводы
для данной версии может существовать или не существовать, мы можем предпочесть
«docs.python.org/3.6/de/», но при этом языки разбросаны повсюду.
Наличие «/de/3.6/» более ясно, что означает: «все, что находится в / de /, написано
по-немецки «. Версия в конце также является привычкой
читатели документации: любят легко менять версию
изменив конец пути.

Итак, мы должны использовать следующий шаблон:
«docs.python.org/LANGUAGE_TAG/VERSION/».

Текущая документация не перемещается в «/ en /», вместо этого
«docs.python.org/en/» будет перенаправлять на «docs.python.org».

Тег языка

Распространенным обозначением языковых тегов является языковой тег IETF.
основан на ISO 639, хотя gettext использует теги ISO 639 с
подчеркивания (например, pt_BR) вместо тире для присоединения к тегам
(например, pt-BR). Примеры языковых тегов IETF: fr (французский),
ja (яп.), pt-BR (Орфографическая формулировка 1943 г. —
Официальный в Бразилии).

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

Заглавные буквы в URL-адресах встречаются редко, и docs.python.org
не использует ни одного, поэтому он может ухудшить читаемость, привлекая внимание,
например: «https://docs.python.org/pt-BR/3.6/library/stdtypes.html».
RFC 5646 (Теги для идентификации языков (IETF)) раздел-2.1
заявляет, что теги не чувствительны к регистру.Поскольку RFC допускает строчные буквы,
и это улучшает читаемость, мы должны использовать теги в нижнем регистре, например
пт-бр.

Мы можем опустить подтег региона, если он не добавляет различения
информация, например: «de-DE» или «fr-FR». (Хотя это могло
имеют смысл, соответственно означая «немецкий, как говорят в Германии»
и «Французский, как говорят во Франции»). Но когда регион подтег
фактически добавляет информацию, например «pt-BR» или «португальский как»
говорят в Бразилии «, его следует сохранить.

Итак, мы должны использовать языковые теги IETF в нижнем регистре, например / fr /,
/ pt-br /, / de / и так далее.

Получение и создание переводов

В настоящее время docsbuild-scripts создают документацию.
Эти сценарии следует изменить, чтобы получать и создавать переводы.

Создание новых переводов похоже на создание новых версий, поэтому пока мы
добавление сложности не так уж и много.

Следует четко настраивать два шага: создание нового языка,
и добавив его в переключатель языка. Это позволяет сделать переходный шаг
между «мы приняли язык» и «переведено достаточно, чтобы быть
обнародовано «.На этом этапе переводчики могут просмотреть свои
модификации d.p.o без создания документации
локально.

Из репозиториев переводов только файлы .po должны быть
открывается скриптом docsbuild, чтобы сохранить поверхность атаки и вероятную
как минимум источники ошибок. Это означает, что никакой перевод не может исправить sphinx
рекламировать свой инструмент для перевода. (Эта особенность должна быть
все равно обрабатывается сфинксом).

Как написать красивый код Python с помощью PEP 8 — Настоящий Python

PEP 8, иногда обозначаемый как PEP8 или PEP-8, — это документ, содержащий рекомендации и передовые методы написания кода Python.Он был написан в 2001 году Гвидо ван Россумом, Барри Варшавой и Ником Когланом. Основная цель PEP 8 — улучшить читаемость и согласованность кода Python.

PEP расшифровывается как Python Enhancement Proposal, и их несколько. PEP — это документ, который описывает новые функции, предлагаемые для Python, и документирует аспекты Python, такие как дизайн и стиль, для сообщества.

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

К концу этого руководства вы сможете :

• Написать код Python, соответствующий PEP 8
• Поймите аргументы, лежащие в основе рекомендаций, изложенных в PEP 8
• Настройте среду разработки, чтобы можно было начать писать код Python, совместимый с PEP 8.

Бесплатный бонус: 5 мыслей о Python Mastery, бесплатный курс для разработчиков Python, который показывает вам план действий и образ мышления, которые вам понадобятся, чтобы вывести свои навыки Python на новый уровень.

Зачем нужен PEP 8

«Читаемость имеет значение».

— Дзен Питона

PEP 8 существует для улучшения читаемости кода Python. Но почему так важна удобочитаемость? Почему написание читаемого кода является одним из руководящих принципов языка Python?

Как сказал Гвидо ван Россум: «Код читают гораздо чаще, чем пишут». Вы можете потратить несколько минут или целый день на написание фрагмента кода для обработки аутентификации пользователя.Написав однажды, вы больше никогда не напишете. Но вам обязательно придется перечитать это снова. Этот фрагмент кода может остаться частью проекта, над которым вы работаете. Каждый раз, когда вы возвращаетесь к этому файлу, вам нужно помнить, что делает этот код и почему вы его написали, поэтому удобочитаемость имеет значение.

Если вы новичок в Python, может быть трудно вспомнить, что делает фрагмент кода через несколько дней или недель после того, как вы его написали. Если вы следуете PEP 8, вы можете быть уверены, что правильно назвали свои переменные.Вы будете знать, что добавили достаточно пробелов, чтобы упростить выполнение логических шагов в коде. Вы также хорошо прокомментировали свой код. Все это будет означать, что ваш код будет более читабельным и к нему будет легче вернуться. Следование правилам PEP 8 для новичка может сделать изучение Python гораздо более приятным занятием.

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

Если у вас есть опыт написания кода Python, возможно, вам придется сотрудничать с другими. Здесь очень важно написать читаемый код. Другие люди, которые, возможно, никогда раньше не встречали вас и не видели ваш стиль программирования, должны будут прочитать и понять ваш код. Наличие руководящих принципов, которым вы следуете и знаете, облегчит другим чтение вашего кода.

Соглашения об именах

«Явное лучше, чем неявное».

— Дзен Питона

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

Примечание : Никогда не используйте однобуквенные имена l , O или I , поскольку они могут быть ошибочно приняты за 1 и 0 , в зависимости от шрифта:

  O = 2 # Может показаться, что вы пытаетесь переназначить 2 на ноль
  

Стили именования

В таблице ниже описаны некоторые из распространенных стилей именования в коде Python и указаны случаи их использования:

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

Как выбрать имена

Выбор имен для ваших переменных, функций, классов и т. Д. Может быть сложной задачей. При написании кода вы должны хорошо продумать свой выбор именования, так как это сделает ваш код более читабельным. Лучший способ называть ваши объекты в Python — использовать описательные имена, чтобы было понятно, что представляет собой объект.

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

>>>

  >>> # Не рекомендуется
>>> x = 'Джон Смит'
>>> у, г = х.расколоть()
>>> print (z, y, sep = ',')
"Смит, Джон"
  

Это будет работать, но вам нужно будет отслеживать, что представляют собой x , y и z . Это также может сбивать с толку соавторов. Более четкий выбор имен будет примерно таким:

>>>

  >>> # Рекомендуется
>>> name = 'Джон Смит'
>>> first_name, last_name = name.split ()
>>> print (last_name, first_name, sep = ',')
"Смит, Джон"
  

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

  # Не рекомендуется
def db (x):
    вернуть x * 2
  

На первый взгляд это может показаться разумным выбором. db () может быть сокращением от double. Но представьте, что вы вернетесь к этому коду через несколько дней. Возможно, вы забыли, чего пытались достичь с помощью этой функции, и тогда было бы сложно угадать, как вы ее сократили.

Следующий пример намного яснее. Если вы вернетесь к этому коду через пару дней после его написания, вы все равно сможете прочитать и понять назначение этой функции:

  # Рекомендуется
def multiply_by_two (x):
    вернуть x * 2
  

Та же философия применяется ко всем другим типам данных и объектам в Python. Всегда старайтесь использовать как можно более краткие, но информативные имена.

Макет кода

«Красивое лучше уродливого.”

— Дзен Питона

То, как вы выкладываете свой код, играет огромную роль в его читабельности. В этом разделе вы узнаете, как добавить вертикальные пробелы, чтобы улучшить читаемость кода. Вы также узнаете, как работать с ограничением строки в 79 символов, рекомендованным в PEP 8.

Пустые строки

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

Обведите функции и классы верхнего уровня двумя пустыми строками. Функции и классы верхнего уровня должны быть достаточно самодостаточными и обрабатывать отдельные функции. Имеет смысл разместить вокруг них дополнительное вертикальное пространство, чтобы было видно, что они разделены:

  класс MyFirstClass:
    проходить


класс MySecondClass:
    проходить


def top_level_function ():
    return None
  

Обведите определения методов внутри классов одной пустой строкой. Внутри класса все функции связаны друг с другом. Рекомендуется оставлять между ними только одну строку:

.

  класс MyClass:
    def first_method (сам):
        return None

    def second_method (сам):
        return None
  

Экономно используйте пустые строки внутри функций, чтобы показать четкие шаги. Иногда сложная функция должна выполнить несколько шагов, прежде чем вернет оператор . Чтобы помочь читателю понять логику внутри функции, может быть полезно оставлять пустую строку между каждым шагом.

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

  def calculate_variance (number_list):
    sum_list = 0
    для номера в number_list:
        sum_list = sum_list + число
    среднее = список_сум / лен (список_числов)

    sum_squares = 0
    для номера в number_list:
        sum_squares = sum_squares + число ** 2
    mean_squares = сумма_квадратов / len (число_список)

    вернуть mean_squares - среднее значение ** 2
  

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

Максимальная длина строки и разрыв строки

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

Конечно, сохранить операторы до 79 или менее символов не всегда возможно. PEP 8 описывает способы, позволяющие операторам занимать несколько строк.

Python предполагает продолжение строки, если код заключен в круглые, квадратные или фигурные скобки:

  функция def (arg_one, arg_two,
             arg_three, arg_four):
    вернуть arg_one
  

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

  из mypkg import example1, \
    пример2, пример3
  

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

Если разрыв строки должен произойти вокруг бинарных операторов, таких как + и * , он должен произойти перед оператором. Это правило происходит из математики. Математики согласны с тем, что прерывание перед бинарными операторами улучшает читаемость. Сравните следующие два примера.

Ниже приведен пример взлома перед бинарным оператором:

  # Рекомендуется
total = (первая_переменная
         + вторая_переменная
         - третья_переменная)
  

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

Теперь давайте посмотрим на пример взлома после бинарного оператора:

  # Не рекомендуется
всего = (первая_переменная +
         вторая_переменная -
         третья_переменная)
  

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

Прерывание перед бинарными операторами дает более читаемый код, поэтому PEP 8 поощряет его. Код, который последовательно прерывает после бинарного оператора, по-прежнему соответствует PEP 8. Однако рекомендуется прерывать двоичный оператор.

Углубление

«Должен быть один — а желательно только один — очевидный способ сделать это».

— Дзен Питона

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

Рассмотрим следующий пример:

  х = 3
если x> 5:
    print ('x больше 5')
  

Оператор print с отступом сообщает Python, что он должен выполняться только в том случае, если оператор if возвращает True .Тот же отступ применяется для указания Python, какой код выполнять при вызове функции или какой код принадлежит данному классу.

Правила отступа ключей, изложенные в PEP 8, следующие:

• Используйте 4 последовательных пробела для обозначения отступа.
• Предпочитаю пробелы вместо табуляции.

Табуляция и пробелы

Как упоминалось выше, при отступе кода следует использовать пробелы вместо табуляции. Вы можете настроить параметры в текстовом редакторе, чтобы выводить 4 пробела вместо символа табуляции при нажатии клавиши Tab .

Если вы используете Python 2 и использовали сочетание табуляции и пробелов для отступа в коде, вы не увидите ошибок при попытке его запустить. Чтобы помочь вам проверить согласованность, вы можете добавить флаг -t при запуске кода Python 2 из командной строки. Интерпретатор выдаст предупреждения, если вы не согласны с использованием табуляции и пробелов:

  $ python2 -t code.py
code.py: непоследовательное использование табуляции и пробелов в отступах
  

Если вместо этого вы используете флаг -tt , интерпретатор будет выдавать ошибки вместо предупреждений, и ваш код не будет запущен.TabError: непоследовательное использование табуляции и пробелов в отступах

Вы можете писать код Python с табуляциями или пробелами, указывающими отступ. Но если вы используете Python 3, вы должны быть последовательны в своем выборе. В противном случае ваш код не запустится. PEP 8 рекомендует всегда использовать 4 последовательных пробела для обозначения отступа.

Отступ после разрывов строки

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

Первый из них — выровнять блок с отступом с открывающим разделителем:

  функция def (arg_one, arg_two,
             arg_three, arg_four):
    вернуть arg_one
  

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

  х = 5
если (x> 3 и
    х <10):
    печать (х)
  

В этом случае PEP 8 предоставляет две альтернативы для улучшения читаемости:

• Добавьте комментарий после последнего условия. Из-за подсветки синтаксиса в большинстве редакторов это отделит условия от вложенного кода:

    х = 5
  если (x> 3 и
      х <10):
      # Оба условия выполнены
      печать (х)
    

• Добавить отступ на продолжении строки:

    х = 5
  если (x> 3 и
          х <10):
      печать (х)
    

Альтернативный стиль отступа после разрыва строки - висячий отступ .Это типографский термин, означающий, что каждая строка, кроме первой в абзаце или утверждении, имеет отступ. Вы можете использовать выступ для визуального представления продолжения строки кода. Вот пример:

  var = function (
    arg_one, arg_two,
    arg_three, arg_four)
  

Примечание : при использовании выступа в первой строке не должно быть никаких аргументов. Следующий пример не соответствует требованиям PEP 8:

  # Не рекомендуется
var = function (arg_one, arg_two,
    arg_three, arg_four)
  

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

  # Не рекомендуется
функция def (
    arg_one, arg_two,
    arg_three, arg_four):
    вернуть arg_one
  

Вместо этого лучше использовать двойной отступ в продолжении строки. Это поможет вам различать аргументы функции и тело функции, улучшая читаемость:

  функция def (
        arg_one, arg_two,
        arg_three, arg_four):
    вернуть arg_one
  

Когда вы пишете код, совместимый с PEP 8, ограничение в 79 символов вынуждает вас добавлять разрывы строк в код.Чтобы улучшить читаемость, вы должны сделать отступ для продолжения строки, чтобы показать, что это непрерывная строка. Это можно сделать двумя способами. Во-первых, выровняйте блок с отступом с открывающим разделителем. Второй - использовать выступ. Вы можете выбрать, какой метод отступа использовать после разрыва строки.

Куда поставить закрывающую скобу

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

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

Пробелы в выражениях и операторах

«Лучше разреженное, чем плотное».

- Дзен Питона

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

Пробелы вокруг двоичных операторов

Заключите следующие бинарные операторы одним пробелом с каждой стороны:

• Операторы присваивания ( = , + = , - = и т. Д.)

• Сравнения ( == , ! = , > , <.> = , <= ) и ( это , не , в , не в )

• Логические ( и , не , или )

Примечание : Когда = используется для присвоения значения по умолчанию аргументу функции, не заключайте его в пробелы.

  # Рекомендуется
Функция def (default_parameter = 5):
    # ...


# Не рекомендуется
Функция def (default_parameter = 5):
    #...
  

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

  # Рекомендуется
у = х ** 2 + 5
г = (х + у) * (х-у)

# Не рекомендуется
у = х ** 2 + 5
г = (х + у) * (х - у)
  

Вы также можете применить это к , если операторы , где есть несколько условий:

  # Не рекомендуется
если x> 5 и x% 2 == 0:
    print ('x больше 5 и делится на 2!')
  

В приведенном выше примере оператор и имеет самый низкий приоритет.Таким образом, может быть более понятным выражение if , как показано ниже:

  # Рекомендуется
если x> 5 и x% 2 == 0:
    print ('x больше 5 и делится на 2!')
  

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

Не допускается следующее:

  # Однозначно не делайте этого!
если x> 5 и x% 2 == 0:
    print ('x больше 5 и делится на 2!')
  

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

  список [3: 4]

# Обрабатывать двоеточие как оператор с самым низким приоритетом
список [x + 1: x + 2]

# В расширенном фрагменте оба двоеточия должны быть
# окружены таким же количеством пробелов
список [3: 4: 5]
список [x + 1: x + 2: x + 3]

# Пробел опускается, если параметр среза опущен
список [x + 1: x + 2:]
  

Таким образом, вы должны окружить большинство операторов пробелами.Однако у этого правила есть некоторые предостережения, например, в аргументах функции или когда вы объединяете несколько операторов в одном операторе.

Когда следует избегать добавления пробелов

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

Самое важное место, чтобы избежать добавления пробелов, - это конец строки. Это известно как конечный пробел .Он невидим и может приводить к ошибкам, которые трудно отследить.

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

• Сразу в скобках, скобках или фигурных скобках:

    # Рекомендуется
  my_list = [1, 2, 3]
  
  # Не рекомендуется
  my_list = [1, 2, 3,]
    

• Перед запятой, точкой с запятой или двоеточием:

    х = 5
  у = 6
  
  # Рекомендуемые
  печать (х, у)
  
  # Не рекомендуется
  печать (х, у)
    

• Перед открывающей круглой скобкой, с которой начинается список аргументов вызова функции:

    def double (x):
      вернуть x * 2
  
  # Рекомендуемые
  двойной (3)
  
  # Не рекомендуется
  двойной (3)
    

• Перед открытой скобкой, с которой начинается индекс или срез:

    # Рекомендуется
  список [3]
  
  # Не рекомендуется
  список [3]
    

• Между запятой и закрывающей круглой скобкой:

    # Рекомендуется
  кортеж = (1,)
  
  # Не рекомендуется
  кортеж = (1,)
    

• Для согласования операторов присваивания:

    # Рекомендуется
  var1 = 5
  var2 = 6
  some_long_var = 7
  
  # Не рекомендуется
  var1 = 5
  var2 = 6
  some_long_var = 7
    

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

Рекомендации по программированию

«Простое лучше, чем сложное».

- Дзен Питона

Вы часто обнаруживаете, что существует несколько способов выполнить аналогичное действие в Python (и на любом другом языке программирования в этом отношении).В этом разделе вы увидите некоторые предложения, которые предлагает PEP 8, чтобы устранить эту двусмысленность и сохранить согласованность.

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

  # Не рекомендуется
my_bool = 6> 5
если my_bool == True:
    return '6 больше 5'
  

Использование оператора эквивалентности == здесь не требуется. bool может принимать только значения True или False . Достаточно написать следующее:

  # Рекомендуется
если my_bool:
    return '6 больше 5'
  

Этот способ выполнения оператора if с логическим значением требует меньше кода и проще, поэтому PEP 8 поддерживает его.

Используйте тот факт, что пустые последовательности ложны в операторах if . Если вы хотите проверить, пуст ли список, у вас может возникнуть соблазн проверить длину списка.Если список пуст, его длина составляет 0 , что эквивалентно False при использовании в инструкции if . Вот пример:

  # Не рекомендуется
my_list = []
если не len (my_list):
    print ('Список пуст!')
  

Однако в Python любой пустой список, строка или кортеж является ложным. Таким образом, мы можем предложить более простую альтернативу приведенному выше:

.

  # Рекомендуется
my_list = []
если не my_list:
    print ('Список пуст!')
  

Пока будут распечатаны оба примера Список пуст! , второй вариант проще, поэтому PEP 8 поощряет его.

Используйте не , а не ... в операторах if . Если вы пытаетесь проверить, имеет ли переменная определенное значение, есть два варианта. Первый - оценить , если оператор с x не равен None , как в примере ниже:

  # Рекомендуется
если x не равно None:
    вернуть "x существует!"
  

Второй вариант - оценить x is None , а затем получить if statement на основе not результат:

  # Не рекомендуется
если не x равно None:
    вернуть "x существует!"
  

Хотя оба варианта будут оценены правильно, первый проще, поэтому PEP 8 поощряет его.

Не используйте , если x: , когда вы имеете в виду , если x не равен None: . Иногда у вас может быть функция с аргументами, которые по умолчанию равны Нет . Распространенной ошибкой при проверке того, имеет ли такой аргумент arg другое значение, является использование следующего:

  # Не рекомендуется
если аргумент:
    # Сделайте что-нибудь с arg ...
  

Этот код проверяет правильность arg . Вместо этого вы хотите проверить, что arg - это , а не None , поэтому было бы лучше использовать следующее:

  # Рекомендуется
если аргумент не равен None:
    # Сделайте что-нибудь с arg...
  

Ошибка здесь заключается в предположении, что not None и truthy эквивалентны. Вы могли установить arg = [] . Как мы видели выше, пустые списки в Python считаются ложными. Таким образом, даже несмотря на то, что аргумент arg был назначен, условие не выполняется, и поэтому код в теле оператора if не будет выполнен.

Используйте .startswith () и .endswith () вместо нарезки. Если вы пытались проверить, была ли строка word префиксом или суффиксом со словом cat , может показаться разумным использование нарезки списка. Однако нарезка списка подвержена ошибкам, и вам необходимо жестко указать количество символов в префиксе или суффиксе. Тем, кто менее знаком с разделением списков Python, непонятно, чего вы пытаетесь достичь:

  # Не рекомендуется
если слово [: 3] == 'кошка':
    print ('Слово начинается с «кот»')
  

Однако это не так удобно, как использование .начинается с () :

  # Рекомендуется
если word.startswith ('кошка'):
    print ('Слово начинается с «кот»')
  

Аналогичным образом, тот же принцип применяется, когда вы проверяете суффиксы. В приведенном ниже примере показано, как можно проверить, заканчивается ли строка на jpg :

.

  # Не рекомендуется
если имя_файла [-3:] == 'jpg':
    print ('Файл в формате JPEG')
  

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

  # Рекомендуется
если имя_файла.endswith ('jpg'):
    print ('Файл в формате JPEG')
  

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

Когда игнорировать PEP 8

Краткого ответа на этот вопрос никогда не бывает. Если вы строго следуете PEP 8, вы можете гарантировать, что у вас будет чистый, профессиональный и читаемый код.Это принесет пользу вам, а также сотрудникам и потенциальным работодателям.

Однако некоторые рекомендации в PEP 8 неудобны в следующих случаях:

• Если соответствие PEP 8 нарушит совместимость с существующим программным обеспечением
• Если код того, над чем вы работаете, несовместим с PEP 8
• Если код должен оставаться совместимым со старыми версиями Python

Советы и приемы, которые помогут обеспечить соответствие вашего кода PEP 8

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

Линтерс

ЛИНТЕРы - это программы, которые анализируют код и помечают ошибки. В них есть предложения, как исправить ошибку. Линтеры особенно полезны при установке в качестве расширений вашего текстового редактора, поскольку они выявляют ошибки и стилистические проблемы во время написания.В этом разделе вы увидите схему работы линтеров со ссылками на расширения текстового редактора в конце.

Лучшие линтеры для кода Python следующие:

• pycodestyle - это инструмент для проверки вашего кода Python на соответствие некоторым стилевым соглашениям в PEP 8.

  Установите pycodestyle , используя pip :

    $ pip install pycodestyle
    

  Вы можете запустить pycodestyle с терминала, используя следующую команду:

    $ код пикодестиля.ру
  code.py:1:17: E231 отсутствует пробел после ','
  code.py:2:21: E231 отсутствует пробел после ','
  code.py:6:19: сравнение E711 с None должно быть 'if cond is None:'
    

• flake8 - это инструмент, который объединяет отладчик, pyflakes , с pycodestyle .

  Установите flake8 с помощью выступа :

  Запустите flake8 с терминала, используя следующую команду:

    $ flake8 код.ру
  code.py:1:17: E231 отсутствует пробел после ','
  code.py:2:21: E231 отсутствует пробел после ','
  code.py:3:17: E999 SyntaxError: недопустимый синтаксис
  code.py:6:19: сравнение E711 с None должно быть 'if cond is None:'
    

  Также показан пример вывода.

Примечание : Дополнительная строка вывода указывает на синтаксическую ошибку.

Они также доступны как расширения для Atom, Sublime Text, Visual Studio Code и VIM. Вы также можете найти руководства по настройке Sublime Text и VIM для разработки Python, а также обзор некоторых популярных текстовых редакторов на Real Python .

Автоформаторы

Автоформаттеры - это программы, которые автоматически реорганизуют ваш код для соответствия PEP 8. Однажды такой программой будет black , которая автоматически форматирует код в соответствии с и большинством правил в PEP 8. Одно большое отличие состоит в том, что она ограничивает длину строки 88 символами, а не 79. Однако вы можете перезаписать это, добавив командную строку flag, как вы увидите в примере ниже.

Установите черный с помощью штифта . Требуется Python 3.6+ для запуска:

Может запускаться через командную строку, как с линтерами. Допустим, вы начали со следующего кода, который не соответствует PEP 8, в файле с именем code.py :

  для i в диапазоне (0,3):
    для j в диапазоне (0,3):
        если (i == 2):
            печать (я, j)
  

Затем вы можете запустить следующую команду через командную строку:

  $ черный code.py
переформатированный code.py
Все сделано! ✨ 🍰 ✨
  

code.py будет автоматически переформатирован, чтобы выглядеть так:

  для i в диапазоне (0, 3):
    для j в диапазоне (0, 3):
        если я == 2:
            печать (я, j)
  

Если вы хотите изменить ограничение длины строки, вы можете использовать флаг --line-length :

  $ черный - длина строки = 79 код.ру
переформатированный code.py
Все сделано! ✨ 🍰 ✨
  

Два других автоформаттера, autopep8 и yapf , выполняют действия, аналогичные тем, что делает black .

Другой учебник Real Python «Качество кода Python: инструменты и передовые методы» Александра ван Тол дает подробное объяснение того, как использовать эти инструменты.

Заключение

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

Из этого урока вы узнали:

• Что такое PEP 8 и почему он существует
• Почему вы должны стремиться написать код, совместимый с PEP 8
• Как написать код, совместимый с PEP 8

Вдобавок ко всему, вы также увидели, как использовать линтеры и автоформаттеры для проверки вашего кода на соответствие рекомендациям PEP 8.

Если вы хотите узнать больше о PEP 8, вы можете прочитать полную документацию или посетить pep8.org, который содержит ту же информацию, но был хорошо отформатирован. В этих документах вы найдете остальные рекомендации по PEP 8, которые не рассматриваются в этом руководстве.

Настройка PEP8 и Pylint на VS Code

Форматирование кода Python для прохождения теста на ремонтопригодность может быть трудным; особенно если вы не получаете помощи. Человеку свойственно устать от избыточности, мы легко хотим быстро выполнить работу и двигаться дальше.Однако это влияет на результат и качество нашей работы. Когда дело доходит до качества кода, первостепенное значение имеет соблюдение стандартов, и нет лучшего способа сделать это, чем следовать некоторым уже установленным стандартам.

PEP8 определяет стандарты кодирования Python; от объявления переменных до форматирования классов. В нем есть все, это позволяет вам красиво отформатировать код Python. Чтобы установить пакет, убедитесь, что вы находитесь в папке проекта и включен virtualenv , если нет, выполните следующие строки в каталоге папки

  $ virtualenv env

$ исходный env / bin / активировать

  

Войти в полноэкранный режимВыйти из полноэкранного режима

Затем установите PEP8

  $ pip install pep8
  

Войти в полноэкранный режимВыйти из полноэкранного режима

Теперь давайте проверим Pylint, этот инструмент проверяет, соблюдаем ли мы стандарты PEP8, и возвращает ошибки там, где мы не соблюдаем.Кроме того, этот инструмент также выполняет проверку ошибок из-за синтаксических ошибок. Чтобы установить pylint, запустите следующий код;

  $ pip install pylint
  

Войти в полноэкранный режимВыйти из полноэкранного режима

Поскольку теперь у нас есть два необходимых инструмента, мы можем открыть код

  $ код.
  

Войти в полноэкранный режимВыйти из полноэкранного режима

Как только мы откроем наш редактор кода vs; мы можем выбрать предпочитаемый интерпретатор, просто нажмите
Ctrl + Shift + P .

Вы должны увидеть что-то похожее на результат выше. Затем мы выбираем наш Python Interpreter

Просто выберите python3 / 2 с включенным virtualenv. Это гарантирует, что код Vs подберет инструменты, которые мы установили в виртуальной среде.

Затем мы, наконец, активируем линтинг по Vs-коду.
Выполните следующие шаги
Файл> Настройки> Настройки> Настройки рабочего пространства> Конфигурация Python
Нажмите Изменить в settings.json

Ваше рабочее пространство должно соответствовать указанным выше параметрам линтинга.После редактирования вашего json сохраните настройки и начните кодирование. Теперь каждый раз, когда вы обращаетесь к Vs Code в virtaulenv, он всегда активирует линтинг.

IDE Эрика Python

Что такое Эрик?

Eric - это полнофункциональный редактор Python и IDE, написанный на Python. это
основанный на кроссплатформенном наборе инструментов Qt UI, интегрирующий очень гибкий
Управление редактором Scintilla. Он разработан так, чтобы его можно было использовать, как всегда, быстро и быстро.
грязный редактор, а также возможность профессионального управления проектами
Инструмент, объединяющий многие расширенные функции Python, предлагает профессиональному программисту.eric включает в себя систему плагинов, которая позволяет легко расширять среду IDE.
функциональность с плагинами, загружаемыми из сети.

Текущая стабильная версия - eric6 на основе PyQt5 (с Qt5) и
Python 3.

Характеристики

• Неограниченное количество редакторов
• Настраиваемое расположение окон
• Подсветка настраиваемого синтаксиса
• Автозаполнение исходного кода
• Подсказки исходного кода
• Сворачивание исходного кода
• Соответствие скоб
• Ошибка выделения
• Расширенные функции поиска, включая поиск по всему проекту
  и заменить
• Встроенный браузер классов
• Интегрированный интерфейс управления версиями для Mercurial, Subversion
  и репозитории Git (как основные плагины)
• Интегрированные функции сотрудничества (чат, общий редактор)
• Интегрированная система документации исходного кода
• Встроенный отладчик Python, включая поддержку отладки
  многопоточные и многопроцессорные приложения
• Интегрированное профилирование и поддержка покрытия кода
• Встроенные средства автоматической проверки кода (синтаксис, ошибки и стиль [PEP-8])
• Управление интегрированными задачами (ToDo items)
• Расширенные возможности управления проектами

• Интерактивная оболочка Python, включая подсветку синтаксиса и автозаполнение
• Схемы приложений
• Запуск внешних приложений из среды IDE
• Встроенная поддержка unittest
• Интегрированная поддержка CORBA на основе omniORB
• Встроенная поддержка Google protobuf
• Интегрированное управление «виртуальной средой»
• Интегрированная поддержка управления пакетами Python (pip)
• Встроенный инструмент рефакторинга веревки (как дополнительный плагин)
• Интегрированный интерфейс для различных упаковщиков (в качестве дополнительных плагинов)
• Интегрированный интерфейс для PyLint (как дополнительный плагин)
• Множество интегрированных мастеров для регулярных выражений и диалогов Qt (как основные плагины)
• Локализации: В настоящее время Эрик доступен на английском, немецком, русском и других языках.
  и испанский.
• Инструменты для предварительного просмотра форм и переводов Qt
• Встроенный веб-браузер
• Интегрированный интерфейс к библиотеке проверки правописания чар
• ... многие, многие другие, не упомянутые здесь

Wing Python IDE 6.1.4: 16 января 2019 г.

Wing Python IDE 6.1.4: 16 января 2019 г.

Wingware выпустила версию 6.1.4 своего семейства кроссплатформенных IDE Python.

Изменения в 6.1,4

Этот второстепенный выпуск исправляет использование typing.IO и подобных классов в качестве подсказок типов,
улучшает обработку разделений редактора в определении goto, исправляет сбой при установке
удаленного агента и исправляет ошибку при преобразовании EOL в редакторе. См. Подробности в журнале изменений.

Загрузить сейчас

О крыле

Семейство кроссплатформенных IDE Python

Wingware делает Python
упрощение разработки благодаря мощным интегрированным функциям редактирования, отладки, модульного тестирования и проекта
особенности управления.Wing работает в Windows, Linux и OS X и может использоваться для разработки любых
вид кода Python для Интернета, настольных компьютеров, научных исследований, анализа данных, встроенных сценариев,
и другие приложения.

Версия 6 представляет множество новых функций, включая улучшенный множественный выбор, гораздо более простую удаленную разработку, отладку из оболочки Python,
рекурсивная отладка,
Хинтинг типа PEP 484 и 526,
Переформатирование PEP 8, поддержка Python 3.6 и 3.7,
возможность создать новый виртуальный
из диалога New Project, улучшенный режим VI, поддержка
Бродяга, Jupyter, Django 1.10+ и 2.0, а также подсистема Windows для
Linux, улучшенная поддержка matplotlib, упрощенная разработка Raspberry Pi, оптимизированный отладчик, полная версия OS X
режим экрана, цветовая палитра One Dark, русская локализация (спасибо Александру Драгукину),
расширенная бесплатная продуктовая линейка и многое другое. Для получения дополнительной информации см. Что нового в Wing версии 6.

Wing 6 работает с Python версий с 2.5 по 2.7 и с 3.2 по 3.7, включая также
Anaconda, ActivePython, EPD, Stackless и другие, унаследованные от CPython.
реализация.

Wing Pro требует покупки или обновления.
лицензию или получение 30-дневной пробной версии при запуске. Крыло 101
и Wing Personal - бесплатные версии
которые опускают некоторые функции.

Для получения дополнительной информации посетите сайт wingware.com

Обновление

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

См. Также Переход со старых версий
и обновление.

PaveTranquil / WWTBAM: Игра «Кто хочет стать миллионером» на русском

Популярное телешоу «Кто хочет стать миллионером?» теперь доступен на вашем ПК! 💙
Линии жизни, вопросы, виртуальные рубли и все игровые подарки - все, что вам нравится в этом игровом шоу, теперь в одном приложении. 💰
Вы можете побить свои рекорды и рекорды друзей, используя таблицу рекордов. 🏆
Стань умнее и проверь свои знания! 📚

Как начать:

1. Откройте свой терминал в папке репо
2. Введите следующие команды:

    pip install -r требования.

 Чт, 2 июля 2020 г., в 05:20 Антуан Питру написал:
> Мы не говорим о размещении «собственного сочинения», мы говорим о
> комментарии (и предположительно документация) в коллективном ПО
> проект.Необходима последовательность, но это
> уточнил и добился.
>
> Иначе зачем останавливаться на английском? Я мог бы просто написать свои комментарии
> По-французски, если все дело в индивидуальной свободе. Требование английского языка
> не всеохватывающе, это заставило людей вроде меня болезненно адаптироваться к
> язык, к которому я не привык. И это не имеет ничего общего с "белым
> превосходство ». 

Действительно, почему?

Наверняка где-нибудь в мире есть люди, которые пишут свои комментарии в
Французский, русский или японский, а также называйте свои переменные в этих
языков, и я бы сказал, что в этом нет ничего плохого (это, безусловно,
В противном случае поддержка Unicode в именах переменных кажется потраченной впустую),
они просто не образуют сплошное сообщество с людьми, чей код находится в
английский

И в этом, я думаю, суть проблемы.Если диалект кто-то хочет
писать свои комментарии в понятной форме со словом "стандарт" (однако
определено) Английский язык нет реальной необходимости обеспечивать более высокую степень соответствия
сверх того. Это можно понять, и этого достаточно. А если это не так,
тогда они фактически являются сообществом программистов на иностранном языке, и есть
нет причин говорить, что они не должны идти своим путем, кроме как для
Французский / русский / японский / и т. Д.

Желание обеспечить более высокую степень соответствия, несмотря на отсутствие такого
необходимость - это то, что некоторые в этой дискуссии назвали «превосходством белых»._______________________________________________
Список рассылки Python-Dev - [email protected]
Чтобы отказаться от подписки, отправьте электронное письмо на адрес python-dev-le ... @ python.org
https://mail.python.org/mailman3/lists/python-dev.python.org/
Сообщение заархивировано в
https://mail.python.org/archives/list/[email protected]/message/ZLFWE2NGCTUJ74FVAZLBIYG3AMTSK3VD/
Кодекс поведения: http://python.org/psf/codeofconduct/