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

Содержание

Если вы хотите назвать переменную одним символом, избегайте маленьких латинских l («el»), заглавной I («ai») и заглавной O — в некоторых шрифтах они неотличимы от цифр 1 и 0 соответственно. С заглавной буквой L такой проблемы нет.

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

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

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

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

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

Две причины нарушить эти правила:

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

Если вы должны использовать Subversion, CVS или RCS для своего исходного кода, сделайте это:

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

Соглашения об именовании переменных в 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 использует префикс X для всех публичных функций. В Python этот стиль считается избыточным, поскольку имена полей и методов имеют префикс к имени объекта, а имена функций — префикс к имени модуля.

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

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

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

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

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

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

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

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

Общие рекомендации

Код должен быть написан так, чтобы не зависеть от разных реализаций языка (PyPy, Jython, IronPython, Pyrex, Psyco и пр.). Например, не полагайтесь на эффективную реализацию в CPython конкатенации строк в выражениях типа a+=b или a=a+b. Такие инструкции выполняются значительно медленнее в Jython. В критичных к времени выполнения частях программы используйте ».join() — таким образом склеивание строк будет выполнено за линейное время независимо от реализации python.
Сравнения с None должны обязательно выполняться с использованием операторов is или is not, а не с помощью операторов сравнения. Кроме того, не пишите if x, если имеете в виду if x is not None — если, к примеру, при тестировании такая переменная может принять значение другого типа, отличного от None, но при приведении типов может получиться False!
При реализации методов сравнения, лучше всего реализовать все 6 операций сравнения (__eq__, __ne__, __lt__, __le__, __gt__, __ge__), чем полагаться на то, что другие программисты будут использовать только конкретный вид сравнения. Для минимизации усилий можно воспользоваться декоратором functools.total_ordering() для реализации недостающих методов. PEP 207 указывает, что интерпретатор может поменять y>x — x= х на х. Однако, лучше всего осуществить все шесть операций, чтобы не возникало путаницы в других местах.
Всегда используйте выражение def, а не присваивание лямбда-выражения к имени. Правильно:

Если обработчик выводит пользователю всё о случившейся ошибке; по крайней мере, пользователь будет знать, что произошла ошибка.
Если нужно выполнить некоторый код после перехвата исключения, а потом вновь «бросить» его для обработки где-то в другом месте. Обычно же лучше пользоваться конструкцией «try. finally».

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

«Сказать лучше, чем не сказать» — Питон Дзен .

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

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

O = 2 # Похоже, что вы пытаетесь присвоить значение 2 нулю.

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

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

Тип	Типы соглашений об именовании	Примеры
Функция	Используйте слово (слова) в нижнем регистре. Выделите слова подчеркиванием.	Функция, my_function
Переменная	Используйте одну букву, слово (слова) в нижнем регистре. Выделяйте слова подчеркиванием для лучшей читабельности.	x, var, my_variable
Класс	Начинайте каждое слово с заглавной буквы. Не разделяйте слова подчеркиванием. Этот стиль называется Pascal Case.	Модель, myClass
Метод	Используйте строчные буквы. Выделяйте слова подчеркиванием для лучшей читабельности.	class_method, method
Исправлено	Используйте одну букву, слово или слова с заглавной буквы. Выделяйте слова подчеркиванием для лучшей читабельности.	CONSTANT, MY_CONSTANT, MY_LONG_CONSTANT.
Раздел	Используйте короткое слово (слова) в нижнем регистре. Выделяйте слова подчеркиванием для лучшей читабельности.	module.py, my_module.py
Пакет	Используйте короткое слово (слова) или слово (слова) со строчной буквы. Не разделяйте слова подчеркиванием.	пакет, mypackage

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

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

Python задачи

Наш канал в telgram с викторинами по Python, задачами для собеседования и решениями.

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

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

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

Размещение кода

«Красивое лучше уродливого», — Дзен Питон.

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

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

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

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

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

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 variant_calculation(number_list): sum_list = 0 for number in number_list: sum_list = sum_list + number middle = sum_list / len(number_list) sum_squared = 0 for number in number_list: sum_squared = sum_squared + number**2 middle_squared = sum_squared / len(number_list) return middle_squared - middle**2

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

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

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

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

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

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

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

из mypkg import example1, \ example2, example3

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

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

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

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

list_of_numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9.

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

list_of_numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9.

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

В следующей статье, посвященной PEP 8, мы обсудим правила комментирования, использование пробелов и выбор операторов и методов.

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

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

Создатель языка, Гвидо ван Россум, принимал участие в создании этого документа.

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

Названия — это всегда сложный вопрос. То же самое происходит и в Python. Нижеследующее является общим руководством к действию.

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

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

Какие стили имён бывают

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

Стили бывают следующих типов:

r — (строчная буква)
R — (заглавная буква)
lowercase — (слово в нижнем регистре)
lower_case_with_underscores — (слова из маленьких букв с нижними подчеркиваниями, «змеиный стиль»)
UPPERCASE — (заглавные буквы)
UPPERCASE_WITH_UNDERSCORES — (слова из заглавных букв с нижними подчеркиваниями)
CapitalizedWords — (слова с заглавными буквами, «верблюжий стиль»). Замечание: когда вы используете аббревиатуры в таком стиле, пишите все буквы аббревиатуры заглавными — HTTPServerError лучше, чем HttpServerError.
mixedCase — (отличается от верблюжьего стиля тем, что первое слово начинается с маленькой буквы, часто встречается в других языках программирования)
Capitalized_Words_With_Underscores — (слова с заглавными буквами и нижними подчеркиваниями)

st_mode — здесь st — это префикс, указывающий на то, что поле относится к системным вызовам POSIX. Этот стиль называется «венгерской нотацией» и почти никогда не используется в Python.

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

_var — слабый признак того, что это имя приватной сущности. Например, from module import * не будет импортировать сущности, чьи имена начинаются с одинарного символа нижнего подчеркивания.
var_ — применяют по соглашению для того чтобы предотвратить конфликт с зарезервированными словами Пайтона, например:

def foo(type_, raise_=None): pass

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

from pprint import pprint class foo(): __myattr = 'private' pprint(dir(foo)) # выход: '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_foo__myattr'.
Как вы можете видеть, атрибут __myattr здесь автоматически изменился на _foo__myattr.

__var__ — (двойное нижнее подчеркивание вокруг имени): магические или «дандер» методы или атрибуты, расположенные в пространствах имен, которыми может управлять пользователь. Например, __name__, __init__ или __call Подобный стиль использовать не стоит.

Имена, которые не стоит использовать
Избегайте использования одиночных символов в именах, которые выглядят как цифры. Это l (строчная латинская буква "el"), O (строчная латинская буква "o") и I (строчная латинская буква "ai").
Имена модулей и пакетов
Поскольку некоторые операционные системы не чувствительны к регистру и усекают длинные имена файлов, модули и пакеты следует называть как можно короче, а имя писать в нижнем регистре. Подчеркивание в нижнем регистре может быть использовано в имени модуля, если это необходимо, но не в имени пакета.
Общие рекомендации

Код должен быть универсальным и написан таким образом, чтобы не зависеть от конкретной реализации языка (PyPy, Brython, Jython, IronPython, Nuitka, Cython и пр.).
Сравнения с None, как и во многих других языках программирования, должны непременно быть выполнены с применением операторов is или is not, но не с использованием операторов сравнения. Так же, вместо if x, следует писать if x is not None так как в некоторых случаях приведения типов значение None может быть приведено к значению False.
При реализации методов сравнения, лучше всего реализовать все 6 операций сравнения (__eq__, __ne__, __lt__, __le__, __gt__, __ge__), чем рассчитывать на то, что другие разработчики будут применять только определённый вид сравнения.

Для реализации недостающих методов можно использовать декоратор total_ordering() из модуля functools стандартной библиотеки.

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

Размещение элементов списка
Если список содержит много элементов, представьте его в виде матрицы, при этом закрывающая скобка переносится на следующую строку. Вот как выглядят ваши списки Python:
my_list = 1, 2, 3, 4, 5, 6,
Вы можете уравновесить закрывающую скобку отступом (такой формат встречается редко):
my_list = 1, 2, 3, 4, 5, 6,
Переносить операторы на следующую строку или нет
Переведите двоичные операторы длинного выражения в следующей строке. Это делает код более читабельным в Python. Не забудьте заключить выражение в квадратные скобки, иначе возникнет ошибка. Например, это может выглядеть следующим образом:
Доход = (валовая задолженность + налогооблагаемые проценты + дивиденды - ira_deduction - проценты по студенческим кредитам).
Но вы НЕ должны оставлять его "висящим":
Доход = (валовая задолженность + налогооблагаемые проценты + дивиденды - ira_deduction - проценты по студенческим кредитам).
Группировка выражений
Расставьте числовые выражения в соответствии с их логикой. Не обязательно ставить пробел после каждой переменной, и не рекомендуется не ставить пробел вообще. Так вы сделаете свой код более "пихоничным":
i = i + 1 submit += 1 x = x*2 - 1 hypot2 = x*x + y*y c = (a+b) * (a-b).
Однако, согласно PEP 8, это НЕ правильный способ:
i=i+1 подать +=1 x = x * x * 2 - 1 hypot2 = x * x + y * y c = (a + b) * (a - b)
Пробел
Вертикальные пробелы улучшают читабельность нашего кода. Давайте рассмотрим некоторые из основных рекомендаций PEP 8 по использованию вертикальных пробелов или пустых строк:

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

Использование пробелов следует избегать в следующих ситуациях:
Идиомы
Проще говоря, идиома программирования - это способ написания кода. Концепция идиом программирования подробно обсуждается в c2 и Stack Overflow.
Идиомы кода Python часто называют питоническими.
Хотя обычно существует один - и желательно только один - очевидный способ сделать это, способ написания идиоматического кода Python может быть неочевидным для новичка в Python. Поэтому хорошие идиомы нужно приобретать сознательно.
Вот некоторые распространенные идиомы Python:
Распаковка
Если вы знаете длину списка или кортежа, вы можете назвать его элементы во время распаковки. Например, функция enumerate() возвращает двухэлементный кортеж для каждого элемента списка:
for index, item in enumerate(some_list): # сделать что-то с индексом и элементом
Вы также можете использовать его для замены переменных:
Неявная декомпрессия также работает:
В Python 3 с помощью PEP3132 был представлен новый расширенный метод распаковки:
a, *остаток = 1, 2, 3 # a = 1, остаток = 2, 3 a, *середина, c = 1, 2, 3, 4 # a = 1, середина = 2, 3, c = 4.
Создать игнорируемую переменную
Если вам нужно присвоить что-то (например, декомпрессию), но эта переменная не нужна, используйте __ :
filename = 'foobar.txt', __, ext = filename.rpartition('.')

Примечание
Многие руководства по стилю Python рекомендуют использовать одинарное подчеркивание " _ " для однократно используемых переменных вместо рекомендуемого здесь двойного подчеркивания " __ "; проблема в том, что " _ " часто используется как псевдоним для функций gettext(), а также в интерактивной подсказке для хранения значения последней функции. Использование двойного подчеркивания так же понятно и почти так же удобно, и исключает риск случайной интерполяции в любом из этих других случаев.

Создайте список длины N того же самого
Используйте * список команд Python:
4_nones = None * 4
Создание списка длины N списков
Поскольку списки являются изменяемыми, оператор * (как указано выше) создает список с N ссылками на один и тот же список, а это не то, что вам нужно. Вместо этого используйте понимание списка:
four_lists = for __ in xrange(4).
Примечание: В Python 3 используйте range() вместо xrange().
Создать строку из списка
Распространенной идиомой при создании строк является использование str.join() для пустой строки.
Буквы = 's', 'p', 'a', 'm' Слово = ''.join(letters).
Это устанавливает значение переменной 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.
>>>Введение в этот "Дзен Python", Тим Питерс Красивое лучше уродливого. Явное лучше неявного. Простое лучше сложного. Сложное лучше сложного. Плоское лучше запутанного. Тонкий лучше, чем плотный. Читабельность очень важна. Особые случаи не настолько особые, чтобы нарушать правила. Но практичность превыше ясности. Ошибки никогда не должны совершаться молча. Если только они не будут явно замалчиваться. Не поддавайтесь искушению угадывать перед лицом двусмысленности. Должен быть один - и желательно только один - очевидный способ сделать это. Даже если этот путь может быть неочевиден на первый взгляд, если только вы не голландец. Лучше сейчас, чем никогда. Хотя "никогда" часто лучше, чем *сейчас*. Если приложение трудно объяснить, это плохая идея. Если приложение легко объяснить, это может быть хорошей идеей. Пространства имен - отличная идея - давайте делать больше таких идей!
Некоторые примеры хорошего стиля Python можно найти здесь. В этих слайдах из группы пользователей Python .
Соглашения PEP8
Вот некоторые соглашения, которых следует придерживаться, чтобы сделать ваш код более читабельным.
Проверьте, равна ли переменная постоянной
Вам не нужно явно сравнивать значение с True, None или 0 - вы можете просто добавить его в оператор if. Список того, что считается ложным, см. в разделе Проверка истинности значения.
Плохо
if attr == True: print 'True!' if attr == None: print 'attr is None!'
Хорошо:
# просто проверьте значение if attr: print 'attr is True!' # или проверьте обратное if not attr: print 'attr is false!' # или, поскольку None считается ложным, проверьте явно, является ли attr None: print 'attr is None!
Доступ к элементу словаря
Не используйте метод dict.has_key(). Вместо этого используйте синтаксис или передайте аргумент по умолчанию для. x - dict.get()
Плохо
d = if d.has_key('hello'): print d'hello' # print 'world' else: print 'default_value'
Хорошо:
d = print d.get('hello', 'default_value') # print 'world' print d.get('thingy', 'default_value') # print 'default_value' # Or: if 'hello' in d: print d'hello'
Короткие способы манипулирования списками
Выражения списков обеспечивают мощный и лаконичный способ работы со списками.
Выражения-генераторы имеют тот же синтаксис, что и списки, но вместо списка возвращают генератор.
Создание нового списка требует больше работы и использует больше памяти. Если вы хотите просматривать только новый список, используйте повторитель.
Плохо
# без необходимости выделяет список всех записей (gpa, name) в памяти valedictorian = max((student.gpa, student.name) for student in graduates)
Хорошо:
valedictorian = ma x((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
Хорошо:
для x в последовательности : 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)
Хорошо:
Используйте список понимания или генератор выражений.
# понимания создают новый объект списка filtered_values = value for value in sequence if value != x # генераторы не создают другой список filtered_values = (value for value in sequence if value != x)
Возможные побочные эффекты изменения исходного списка
Изменение первоначального списка может быть опасным, если упомянуты другие переменные. Но вы можете использовать назначение срезов, если очень хотите.
Другое важное о Python в PEP 8

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

Попробуйте:что-то()в дополнение кИсключениеasexc:УвеличитьAnotherDamnError(str(exc))

Старайтесь минимизировать количество кода в конструкциях try… except. Это поможет избежать трудных в обнаружении ошибок.
По возможности выбирайте синтаксис, который работает для всех реализаций Python: CPython, Jython, PyPy и других.

Автоматическая PEP проверка Python-кода
Пока вы создаете небольшие проекты, проверить код на наличие ошибок и нарушений стиля не составит труда. Если вы работаете над большим проектом, вам могут помочь скрипты автоматической проверки. PyCharm проверяет ваш код на лету. Что делать, если вам нужно работать без IDE? На GitHub есть Python Code Quality Authority, содержащий инструменты, которые помогут вам улучшить качество вашего кода, включая средства проверки стиля PEP 8: flake8, pycodestyle, pep8-naming. При необходимости вы можете интегрировать Flake8 в свою среду разработки.

Осознанная необходимость
Помните, что вы должны быть знакомы с PEP 8, но не всегда должны следовать ему. Отступы должны соблюдаться, иначе интерпретатор откажется выполнять ваш код. Однако в самом руководстве упоминаются случаи, когда продюсер может и должен нарушать рекомендации по своему усмотрению.
Если какой-то код становится уродливым при стилизации, то "нам не нужен такой хоккей". Например, если разбиение кода на строки по 72 символа затрудняет его чтение, PEP 8 предлагает расширить строку до 80 или даже 100 символов - в зависимости от того, что удобнее для вас и вашей команды разработчиков. Явные ограничения распространяются только на проекты публичных библиотек. Дальнейшее чтение: Если вам захочется, добавьте в свой список статью "Пишем как настоящий питонист: идиомы Python". Мы также рекомендуем вебинар по использованию Python в реальном мире.