Оформление кода на Python по PEP 8
Обновлено:
Что такое PEP 8
PEP 8 — это руководство по оформлению Python-кода.
Оно описывает, как рекомендуется:
- расставлять отступы и пробелы;
- переносить длинные строки;
- называть переменные, функции и модули;
- оформлять импорты;
- писать условия и другие конструкции;
- организовывать код так, чтобы его было удобно читать.
Основная задача PEP 8 — сделать код понятным, единообразным и удобным для сопровождения.
Представим, что над одним проектом работают несколько программистов. Если каждый будет оформлять код по-своему, читать и изменять такой проект станет сложнее.
Поэтому в Python существуют общепринятые рекомендации по стилю.
Важно понимать: PEP 8 — это не набор обязательных синтаксических требований. Python может прекрасно выполнять код, который оформлен не по PEP 8.
При этом в конкретном проекте могут быть свои правила оформления. Главное — придерживаться единого стиля и не ухудшать читаемость кода ради формального соблюдения рекомендаций.
1. Отступы — четыре пробела
В Python отступы являются частью синтаксиса.
Например:
temperature = 25
if temperature > 20:
print('На улице тепло')
После:
if temperature > 20:
тело условия должно иметь отступ.
PEP 8 рекомендует использовать четыре пробела на каждый уровень вложенности.
Хорошо:
numbers = [10, -5, 20, -15]
for number in numbers:
if number > 0:
print(number)
Здесь:
- тело
forимеет отступ четыре пробела; - тело вложенного
if— восемь пробелов.
Неудачно:
numbers = [10, -5, 20, -15]
for number in numbers:
if number > 0:
print(number)
В этом примере используются отступы по два пробела. Такой код может выполняться, но не соответствует рекомендуемому стилю Python.
Пробелы вместо табуляции
Для отступов рекомендуется использовать пробелы, а не символы табуляции.
Современные редакторы, например Visual Studio Code, обычно умеют автоматически вставлять четыре пробела при нажатии клавиши Tab.
Поэтому вручную нажимать пробел четыре раза необязательно.
Также не следует смешивать табуляцию и пробелы в отступах: это может привести к ошибкам, включая TabError.
2. Перенос длинных вызовов функций
Когда функция принимает много аргументов, её вызов может не помещаться в одну строку.
Неудачно:
total = calculate_order_total(price, quantity,
delivery_cost, discount)
Продолжение строки почти не отличается от обычного кода и визуально плохо связано с открывающей скобкой.
Хорошо:
total = calculate_order_total(
price,
quantity,
delivery_cost,
discount,
)
Аргументы вынесены на отдельные строки и имеют дополнительный отступ.
Есть и другой допустимый вариант — выравнивание по открывающей скобке:
total = calculate_order_total(price, quantity,
delivery_cost, discount)
Оба подхода разрешены.
Для длинных вызовов с большим количеством аргументов первый вариант часто удобнее.
3. Перенос параметров при определении функции
Аналогичные правила применяются к параметрам функции.
Например:
def calculate_order_total(
price: float,
quantity: int,
delivery_cost: float = 0,
) -> float:
return price * quantity + delivery_cost
Здесь список параметров имеет дополнительный отступ, позволяющий отличить его от тела функции.
Тело функции:
return price * quantity + delivery_cost
располагается с обычным отступом в четыре пробела.
Главное — сделать так, чтобы продолжение объявления функции было визуально отделено от её тела.
В разных проектах можно встретить и другие согласованные варианты выравнивания многострочных сигнатур.
4. Длинные условия if
Условие тоже может оказаться слишком длинным.
Например, мы хотим проверить несколько требований одновременно.
Неудачно:
if account_is_active and balance > 0 and not account_is_blocked and attempts < 5:
print('Доступ разрешён')
Такую строку сложнее читать, особенно если условий станет ещё больше.
Лучше:
if (
account_is_active
and balance > 0
and not account_is_blocked
and attempts < 5
):
print('Доступ разрешён')
Каждое условие хорошо видно.
Обратите внимание, что мы используем круглые скобки. Благодаря им выражение можно переносить без обратного слеша \.
PEP 8 допускает разные способы выравнивания многострочных условий. Важно, чтобы само условие легко отличалось от тела if.
5. Закрывающие скобки в многострочных конструкциях
Когда список, словарь или вызов функции занимает несколько строк, закрывающую скобку удобно ставить отдельно.
Хорошо:
numbers = [
10,
20,
30,
]
Или:
user = {
'name': 'Alex',
'age': 30,
'city': 'Tbilisi',
}
Аналогично для вызова функции:
print(
'Python',
'SQL',
'Django',
sep=' | ',
)
Так сразу видно, где заканчивается конструкция.
PEP 8 допускает несколько вариантов выравнивания закрывающих скобок. В наших примерах будем чаще использовать вариант, где закрывающая скобка находится на уровне начала конструкции.
6. Максимальная длина строки
PEP 8 рекомендует:
- 79 символов — для обычной строки кода;
- 72 символа — для комментариев и документационных строк.
Ограничение позволяет удобно просматривать несколько файлов рядом, сравнивать изменения кода и работать в редакторах с небольшими окнами.
Например, вместо длинной строки:
total = product_price * product_quantity + delivery_cost - discount
можно написать:
total = (
product_price * product_quantity
+ delivery_cost
- discount
)
Также длинные строки можно разделять на части:
message = (
'Ваш заказ успешно оформлен. '
'Информацию о доставке отправим отдельно.'
)
Соседние строковые литералы внутри скобок Python объединит в одну строку.
Обязательно ли всегда использовать 79 символов?
Необязательно.
Некоторые команды договариваются о другом ограничении, например 88 или 99 символах.
PEP 8 допускает увеличение длины строки до 99 символов в проектах, где команда согласовала такой стиль.
Но для начала удобно ориентироваться на классические 79 символов.
7. Где переносить математический оператор
Когда математическое выражение занимает несколько строк, возникает вопрос: переносить оператор в конец предыдущей строки или в начало следующей?
Оба способа технически допустимы.
Но для нового кода PEP 8 рекомендует чаще размещать оператор в начале новой строки.
Менее удобно:
total = (product_price +
delivery_cost +
service_fee -
discount)
Предпочтительно:
total = (
product_price
+ delivery_cost
+ service_fee
- discount
)
Во втором примере легче увидеть:
- какие значения складываются;
- какие вычитаются;
- как устроено всё выражение.
Особенно это помогает, когда арифметических операций много.
8. Пустые строки между функциями
Если в файле определено несколько функций верхнего уровня, PEP 8 рекомендует разделять их двумя пустыми строками.
Хорошо:
def calculate_area(width, height):
return width * height
def calculate_perimeter(width, height):
return 2 * (width + height)
def calculate_diagonal(width, height):
return (width ** 2 + height ** 2) ** 0.5
Пустые строки визуально разделяют самостоятельные части программы.
Внутри одной функции также можно оставлять пустые строки между логическими блоками.
Например:
def calculate_total(prices, discount):
subtotal = sum(prices)
discount_amount = subtotal * discount / 100
total = subtotal - discount_amount
return total
Но не стоит разделять пустой строкой каждое действие. Отступы и пустые строки должны помогать читать программу, а не создавать лишние разрывы.
Импорты
9. Импортируем разные модули отдельно
PEP 8 рекомендует каждый отдельный модуль импортировать на новой строке.
Неудачно:
import math, random, time
Хорошо:
import math
import random
import time
При этом из одного модуля можно импортировать сразу несколько объектов:
from random import choices, randint
Это допустимый вариант.
10. Группировка импортов
Импорты обычно находятся в начале Python-файла.
PEP 8 рекомендует разделять их на три группы:
- Стандартная библиотека Python.
- Сторонние библиотеки.
- Собственные модули проекта.
Между группами оставляем пустую строку.
Например:
import math
import random
from collections.abc import Iterable
import numpy as np
import requests
from helpers import format_price
Здесь предполагается, что сторонние библиотеки установлены, а helpers.py — собственный модуль нашего проекта.
Такая организация помогает сразу понять, какие внешние зависимости использует программа.
Внутри групп часто применяется алфавитная сортировка. Это распространённое соглашение, хотя PEP 8 не требует строго определённого алфавитного порядка каждого импортируемого имени.
Также рекомендуется избегать:
from math import *
потому что такой импорт делает менее очевидным происхождение имён в программе.
Пробелы
11. Не ставим лишние пробелы внутри скобок
Неудачно:
numbers = [ 10, 20, 30 ]
coordinates = ( 15, 25 )
user = { 'name': 'Alex', 'age': 30 }
print( 'Hello' )
Хорошо:
numbers = [10, 20, 30]
coordinates = (15, 25)
user = {'name': 'Alex', 'age': 30}
print('Hello')
Лишние пробелы сразу после открывающей или перед закрывающей скобкой обычно не добавляют читаемости.
12. Не ставим пробел перед вызовом функции
Неудачно:
print ('Python')
len (numbers)
calculate_total (10, 20)
Хорошо:
print('Python')
len(numbers)
calculate_total(10, 20)
Название функции должно непосредственно примыкать к открывающей круглой скобке.
13. То же самое с индексами
Неудачно:
numbers = [10, 20, 30]
first = numbers [0]
Хорошо:
numbers = [10, 20, 30]
first = numbers[0]
То же правило действует при работе со словарями:
user = {'name': 'Alex'}
print(user['name'])
Не нужно писать:
user ['name']
14. Пробелы рядом с запятыми и двоеточиями
Обычно пробел ставится после запятой, но не перед ней.
Неудачно:
numbers = [10 ,20 ,30]
print(10 ,20 ,30)
Хорошо:
numbers = [10, 20, 30]
print(10, 20, 30)
Аналогично с двоеточием словаря.
Неудачно:
user = {
'name' : 'Alex',
'age' : 30,
}
Хорошо:
user = {
'name': 'Alex',
'age': 30,
}
Пробел после двоеточия есть, перед ним — нет.
То же относится к двоеточию после if, for, while и def: непосредственно перед ним лишний пробел не нужен.
15. Пробелы в срезах
Срезы немного отличаются от обычных перечислений.
Для простых границ пробелы вокруг двоеточия не нужны.
Хорошо:
numbers[1:5]
numbers[:10]
numbers[::2]
numbers[2:10:3]
Неудачно:
numbers[1 :5]
numbers[1: 5]
numbers[2 : 10 :3]
Если же границы среза являются сложными выражениями, пробелы вокруг двоеточия могут улучшать читаемость:
numbers[start + offset : stop + offset]
Главное — соблюдать одинаковое расстояние с обеих сторон двоеточия, если соответствующие границы указаны.
16. Пробелы вокруг операторов
Обычно бинарные операторы отделяют пробелами с обеих сторон.
Неудачно:
total=100
total+=20
result=10+20
if total>=100:
print(result)
Хорошо:
total = 100
total += 20
result = 10 + 20
if total >= 100:
print(result)
Это относится к операторам:
=
+=
-=
==
!=
<
>
<=
>=
А также к логическим выражениям:
if is_active and balance > 0:
print('Разрешено')
Операторы разного приоритета
Необязательно окружать пробелами абсолютно каждый арифметический оператор, если более компактная запись помогает увидеть приоритет вычислений.
Например:
result = x*x + y*y
PEP 8 допускает такой стиль.
Вариант:
result = x * x + y * y
тоже распространён.
Главное — не использовать случайное количество пробелов и придерживаться выбранного оформления.
17. Не выравниваем присваивания множеством пробелов
Иногда программисты пытаются выстроить все знаки равенства в одну вертикальную линию.
Неудачно:
name = 'Alex'
age = 30
country = 'Georgia'
is_active = True
Хорошо:
name = 'Alex'
age = 30
country = 'Georgia'
is_active = True
Почему второй вариант лучше?
Если добавить переменную с более длинным названием, не придётся перестраивать пробелы во всех остальных строках.
Кроме того, код выглядит привычнее для Python-разработчиков.
18. Пробелы в именованных аргументах
Мы уже умеем передавать аргументы по имени:
print(
'Python',
'SQL',
sep=' | ',
)
В таких случаях пробелы вокруг = обычно не ставятся.
Неудачно:
print('Python', 'SQL', sep = ' | ')
Хорошо:
print('Python', 'SQL', sep=' | ')
То же самое относится к параметрам со значениями по умолчанию, если они не аннотированы.
Хорошо:
def calculate_price(price, discount=0):
return price - discount
Неудачно:
def calculate_price(price, discount = 0):
return price - discount
19. Пробелы при аннотациях типов
В аннотациях действуют немного другие правила.
Между именем и двоеточием пробел не нужен, а после двоеточия нужен.
Неудачно:
price:float = 100
quantity : int = 5
Хорошо:
price: float = 100
quantity: int = 5
Если параметр функции одновременно аннотирован и имеет значение по умолчанию, вокруг = ставятся пробелы.
def calculate_price(
price: float,
discount: float = 0,
) -> float:
return price - discount
Также обязательно используем пробелы вокруг стрелки возвращаемого значения:
def get_name() -> str:
return 'Alex'
Неудачно:
def get_name()->str:
return 'Alex'
20. Убираем пробелы в конце строк
В конце строки могут случайно остаться невидимые пробелы или символы табуляции.
Обычно это происходит при ручном редактировании кода.
Такие символы не несут полезной информации и могут создавать проблемы с инструментами проверки или контроля версий.
Многие редакторы позволяют автоматически удалять пробелы в конце строк при сохранении файла.
Это полезно включить в настройках редактора.
Оформление отдельных конструкций
21. Не записываем несколько инструкций в одну строку
Python позволяет использовать точку с запятой для разделения инструкций:
first = 10; second = 20; print(first + second)
Но такой код хуже читается.
Лучше:
first = 10
second = 20
print(first + second)
Каждая самостоятельная операция находится на своей строке.
Аналогично с условиями.
Неудачно:
if age >= 18: print('Совершеннолетний')
Хорошо:
if age >= 18:
print('Совершеннолетний')
И с циклом:
Неудачно:
for number in numbers: total += number
Хорошо:
for number in numbers:
total += number
Такой стиль особенно важен, когда логика со временем становится сложнее.
22. Запятая в конце многострочных коллекций
В многострочных списках, словарях, вызовах функций и импортах часто удобно оставлять запятую после последнего элемента.
Например:
languages = [
'Python',
'Java',
'Go',
]
Или:
user = {
'name': 'Alex',
'age': 30,
}
Последняя запятая здесь необязательна.
Но если позже добавить новый элемент, достаточно будет вставить ещё одну строку:
languages = [
'Python',
'Java',
'Go',
'JavaScript',
]
Такое оформление удобно при частом редактировании кода и работе с системами контроля версий.
При этом в коротких конструкциях на одной строке лишняя завершающая запятая обычно не нужна:
numbers = [10, 20, 30]
23. Исключение — кортеж из одного элемента
Мы уже знаем, что для создания tuple с одним элементом нужна запятая.
Хорошо:
numbers = (10,)
Без запятой:
numbers = (10)
мы получим обычный int.
Технически можно написать:
numbers = 10,
и Python тоже создаст кортеж.
Но вариант с круглыми скобками:
numbers = (10,)
лучше показывает, что мы намеренно создаём именно tuple.
Имена в Python
24. Переменные и функции — snake_case
PEP 8 рекомендует писать имена переменных и функций строчными буквами.
Если имя состоит из нескольких слов, разделяем их нижним подчёркиванием.
Такой стиль называется:
snake_case
Неудачно:
userName = 'Alex'
UserAge = 30
def CalculateTotal():
...
Хорошо:
user_name = 'Alex'
user_age = 30
def calculate_total():
...
Названия также должны отражать назначение объекта.
Например:
total_price = 1500
обычно понятнее, чем:
tp = 1500
Короткие имена допустимы там, где их смысл очевиден, например x и y для координат или i для простого счётчика.
25. Названия Python-файлов
Имена модулей рекомендуется делать короткими и писать строчными буквами.
Например:
main.py
settings.py
calculator.py
Если название состоит из нескольких слов, можно использовать нижнее подчёркивание:
data_processing.py
user_settings.py
price_calculator.py
Менее удачные варианты:
DataProcessing.py
UserSettings.py
PRICE_CALCULATOR.py
Здесь мы говорим об обычных названиях модулей, а не об именах классов, правила для которых изучим позже.
26. Константы — заглавными буквами
Константы в Python принято обозначать заглавными буквами.
Если название состоит из нескольких слов, между ними используется _.
Например:
MAX_ATTEMPTS = 5
DEFAULT_LANGUAGE = 'ru'
SECONDS_PER_MINUTE = 60
Такие имена сразу показывают разработчику, что значение предполагается использовать как константу.
При этом Python технически не запрещает изменить его:
MAX_ATTEMPTS = 10
То есть это соглашение между разработчиками, а не механизм защиты значения от изменения.
Рекомендации по написанию кода
27. Для None используем is и is not
Если нужно проверить, содержит ли переменная объект None, рекомендуется использовать операторы идентичности.
Неудачно:
if result == None:
print('Результата нет')
Хорошо:
if result is None:
print('Результата нет')
Аналогично для отрицания.
Неудачно:
if not result is None:
print(result)
Хорошо:
if result is not None:
print(result)
Второй вариант выглядит естественнее и лучше читается.
Не путаем None и ложные значения
Например:
result = 0
Условие:
if not result:
print('Нет значения')
выполнится, хотя result не равен None.
Потому что:
bool(0)
возвращает False.
Если важно проверить именно отсутствие значения, пишем:
if result is None:
print('Значение отсутствует')
Так мы не перепутаем None с нулём, пустой строкой или пустой коллекцией.
28. Не сравниваем логические значения с True и False без необходимости
Предположим:
is_active = True
Неудачно:
if is_active == True:
print('Активен')
Хорошо:
if is_active:
print('Активен')
Условие и так проверяет логическое значение.
Аналогично:
Неудачно:
if is_active == False:
print('Неактивен')
Хорошо:
if not is_active:
print('Неактивен')
Такая запись короче и понятнее.
Отдельный случай — когда нужно проверить идентичность именно с объектом True, а не просто истинность значения. Тогда is True имеет другой смысл, но в обычных условиях он не нужен.
29. Проверка пустой коллекции
Мы знаем, что пустые:
list
tuple
str
dict
set
имеют ложное логическое значение.
Поэтому для проверки непустой коллекции можно написать:
if numbers:
print('Список не пуст')
А для проверки пустой:
if not numbers:
print('Список пуст')
В подобных случаях необязательно писать:
if len(numbers) > 0:
print('Список не пуст')
или:
if len(numbers) == 0:
print('Список пуст')
Обычная проверка истинности лучше передаёт намерение: нам важно наличие элементов, а не конкретная длина.
Но если действительно нужно сравнить количество элементов, len() вполне уместна:
if len(numbers) >= 5:
print('Достаточно элементов')
30. Для проверки типа используем isinstance()
Мы уже познакомились с функцией:
isinstance()
PEP 8 рекомендует использовать её для обычных проверок принадлежности объекта типу.
Менее предпочтительно:
if type(value) is int:
print('Целое число')
Предпочтительно:
if isinstance(value, int):
print('Целое число')
Почему?
isinstance() предназначена для проверки типа объекта с учётом наследования.
А:
type(value) is int
проверяет именно точный класс.
Если необходимо намеренно проверить точный тип объекта, type() тоже может быть подходящим инструментом. Но для большинства обычных проверок удобнее isinstance().
31. Для проверки начала строки используем startswith()
Предположим, нужно определить, начинается ли строка с:
https://
Можно использовать срез:
url = 'https://example.com'
if url[:8] == 'https://':
print('HTTPS')
Но понятнее:
url = 'https://example.com'
if url.startswith('https://'):
print('HTTPS')
Вторая запись прямо показывает, что мы проверяем начало строки.
Аналогично для окончания строки.
Менее удобно:
filename = 'report.pdf'
if filename[-4:] == '.pdf':
print('PDF-файл')
Предпочтительно:
filename = 'report.pdf'
if filename.endswith('.pdf'):
print('PDF-файл')
Использование startswith() и endswith() обычно делает намерение программы понятнее и снижает вероятность ошибки при указании длины среза.
32. Соблюдаем единый стиль return
Функция может возвращать значение в разных местах.
Например:
def find_positive(numbers):
for number in numbers:
if number > 0:
return number
return None
Здесь функция либо возвращает найденное число, либо явно возвращает:
None
Менее удачно:
def find_positive(numbers):
for number in numbers:
if number > 0:
return number
return
В обоих случаях результат при отсутствии числа будет None.
Но явный:
return None
лучше показывает, что функция сознательно возвращает отсутствие значения.
Общее правило:
Если функция предназначена для возвращения результата, рекомендуется делать возврат значения последовательным и понятным во всех ветках.
Для функций, которые только выполняют действия и не возвращают полезного результата, обычный:
return
тоже допустим.
Дополнительные рекомендации
33. Комментарии должны объяснять, а не повторять код
Мы уже умеем писать комментарии:
# Комментарий
PEP 8 рекомендует делать их понятными и поддерживать в актуальном состоянии.
Например, такой комментарий почти бесполезен:
total += 1 # Увеличиваем total на единицу.
Мы и так видим, что происходит.
Более полезный комментарий объясняет причину действия:
# Первый заказ получает дополнительный бонус.
if order_count == 0:
bonus += 100
Пробел после #
Обычно пишем:
# Проверяем наличие доступных товаров.
а не:
#Проверяем наличие доступных товаров.
Если комментарий расположен справа от кода, PEP 8 рекомендует отделять его минимум двумя пробелами:
MAX_RETRIES = 3 # Максимум повторных попыток.
Не следует добавлять комментарии к каждой строчке. Комментарий полезен там, где он сообщает что-то, чего нельзя легко понять из самого кода.
34. Используем кавычки последовательно
В Python строки можно записывать как в одинарных, так и в двойных кавычках.
name = 'Alex'
и:
name = "Alex"
полностью равнозначны.
PEP 8 не требует всегда использовать только одинарные или только двойные кавычки.
Но рекомендует соблюдать единый стиль.
Например, если большинство строк проекта использует одинарные кавычки:
name = 'Alex'
city = 'Tbilisi'
language = 'Python'
лучше придерживаться такого же оформления и дальше.
При этом можно использовать другой тип кавычек, чтобы избежать лишнего экранирования:
message = "It's a beautiful day"
Вместо:
message = 'It\'s a beautiful day'
Главная цель — читаемость.
Общий принцип PEP 8
35. Читаемость важнее формального соблюдения каждого правила
PEP 8 — это руководство, а не запрет на любые другие варианты оформления.
Например, такие выражения:
result = x * x + y * y
и:
result = x*x + y*y
могут быть одинаково понятными.
В некоторых проектах используются собственные правила форматирования, которые не полностью совпадают с классическими рекомендациями PEP 8.
Поэтому при работе над реальным проектом важно учитывать:
- общепринятые рекомендации Python;
- правила конкретной команды;
- единообразие существующего кода;
- читаемость конкретного участка программы.
Не стоит переделывать работающий код исключительно ради косметических изменений, если это ухудшает его читаемость или нарушает согласованный стиль проекта.
Краткая памятка
| Что оформляем | Основная рекомендация |
|---|---|
| Отступы | 4 пробела |
| Табуляция | Предпочитаем пробелы |
| Длина строки | Обычно не более 79 символов |
| Комментарии | Рекомендуется до 72 символов |
| Длинные выражения | Переносим внутри скобок |
| Пустые строки между функциями | Обычно две |
| Разные модули | Отдельные строки импорта |
| Группы импортов | Стандартные, сторонние, собственные |
| Пробелы внутри скобок | Обычно не ставим |
| Вызов функции | function(...) |
| Индексация | values[index] |
| Присваивание | name = value |
| Именованные аргументы | name=value |
| Аннотированные параметры с default | name: str = 'Alex' |
| Переменные и функции | snake_case |
| Константы | UPPER_CASE |
Сравнение с None |
is None, is not None |
| Проверка типа | isinstance() |
| Проверка пустой коллекции | if values, if not values |
| Начало строки | startswith() |
| Конец строки | endswith() |
| Несколько инструкций | Обычно на отдельных строках |
Главное по теме
PEP 8 помогает писать Python-код, который удобно читать, редактировать и поддерживать.
Главная идея:
Хороший код должен быть не только рабочим, но и понятным другим разработчикам.
Поэтому уже сейчас стоит привыкать:
- использовать правильные отступы;
- не писать слишком длинные строки;
- аккуратно расставлять пробелы;
- давать переменным и функциям понятные названия;
- правильно оформлять импорты;
- использовать привычные для Python конструкции.
Со временем большая часть этих правил станет привычкой, и следить за каждым пробелом вручную уже не потребуется.
Современные редакторы и инструменты форматирования могут автоматически выполнять значительную часть такой работы.
Это ещё не весь PEP 8
В данном конспекте мы рассмотрели основные правила PEP 8, которые уже можем применять с текущими знаниями Python.
Это большая часть базовых рекомендаций, которых будет достаточно на достаточно долгом этапе обучения.
Но официальный PEP 8 значительно шире. Он также содержит правила оформления классов, методов, атрибутов, исключений, публичных и внутренних интерфейсов и других конструкций.
После изучения объектно-ориентированного программирования (ООП) мы ещё вернёмся к PEP 8 и рассмотрим оставшиеся важные рекомендации.
А пока главное — закрепить изученные правила и постепенно применять их при написании собственных программ.
Официальная документация: PEP 8 — Style Guide for Python Code.