Как писать код на python

4.3.2 Не используйте более одного пробела вокруг оператора присваивания (или любого другого оператора) для того, чтобы выровнять его с другим.

 price = 1000 price_with_taxes = 1200 price_with_taxes_and_discounts = 1100 

 price = 1000 price_with_taxes = 1200 price_with_taxes_and_discounts = 1100 

4.3.3 Не используйте пробелы по сторонам знака = , когда вы используете его, чтобы указать на именованный аргумент или значение по умолчанию.

 def complex(real, imag=0.0): return magic(r=real, i=imag) 

 def complex(real, imag = 0.0): return magic(r = real, i = imag) 

5. Длина строк

Ограничивайте длину строк 79 символами (а длину строк документации и комментариев — 72 символами). В общем случае не используйте обратный слеш в качестве перехода на новую строку. Используйте доступное в Python явное объединение строк посредством круглых и фигурных скобок. Если необходимо, можно добавить дополнительную пару скобок вокруг выражения.

 style_object(self, width, height, color='black', design=None, emphasis=None, highlight=0) if (width == 0 and height == 0 and color == 'red' and emphasis == 'strong'): 

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

 long_string = ('This will build a very long long ' 'long long long long long long string') 

Что касается длинных URL в комментариях, то располагайте их, если это необходимо, на одной строке.

 # See details at # http://www.example.com/example/example/example/example/example/example/example_example.html 

 # See details at # http://www.example.com/example/example/example/example/example/\ # example/example_example.html 

Обратный слеш иногда используется. Например, с длинной конструкцией 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 .

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

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

 import os . . class MyClass: . def __init__(self): self.name = 'My name' . def f(self): return 'hello world' . . def MyFunc(): i = 12345 return i . myclass = MyClass() 

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

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

7. Имена

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

Односимвольные имена, исключая счетчики либо итераторы. Никогда не используйте символы l (маленькая латинская буква «эль»), O (заглавная латинская буква «о») или I (заглавная латинская буква «ай») как однобуквенные идентификаторы. В некоторых шрифтах эти символы неотличимы от цифры один и нуля. Если очень нужно l , пишите вместо неё заглавную L . Хорошо

 long_name = 'Хорошее имя переменной' L = 'Допустимо, но лучше избегать' 

 l = 1 I = 1 O = 0 

 import my_module 

 import my-module 

 my_variable = 'Variable' 

 __myvariable__ = 'Variable' 

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

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

 my_variable = 'Variable' 

 My-Variable = 'Variable' 

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

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

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

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

 import vkapi 

 import My-First-VKontakte-API-Modul 

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

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

 class MyFirstClass: 

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

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

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

7.4 Имена констант

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

 MAX_OVERFLOW = 10 TOTAL = 100 

8. Комментарии

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

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

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

Если вы — программист, не говорящий по-английски, то всё равно следует использовать английский язык для написания комментариев. Особенно, если нет уверенности на 120% в том, что этот код будут читать только люди, говорящие на вашем родном языке.

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

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

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

8.2 Комментарии в строке с кодом

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

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

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

 counter = counter + 1 # Increment counter 

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

Соглашения о написании хорошей документации (docstrings) зафиксированы в PEP 257.

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

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

 """Return something useful Optional plotz says to frobnicate the bizbaz first. """ 

Для однострочной документации можно оставить """ на той же строке.

9. Циклы

9.1 Циклы по спискам

Если нам необходимо в цикле пройти по всем элементам списка, то хорошим тоном (да и более читаемым) будет такой способ:

 colors = ['red', 'green', 'blue', 'yellow'] for color in colors: print(color) 

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

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)): print(colors[i]) 

А если нужно пройти по списку задом наперед, то лучше всего использовать метод reversed:

 colors = ['red', 'green', 'blue', 'yellow'] for color in reversed(colors): print(color) 

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

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)-1, -1, -1): print(colors[i]) 

9.2 Циклы по списку чисел

Если есть необходимость пройти в цикле по ряду чисел, то метод range будет намного приемлемее, как минимум потому, что этот метод потребляет намного меньше памяти, чем вариант в блоке "Плохо". А представьте, что у вас ряд из трёх миллиардов последовательных чисел!

 for i in range(6): print(i**2) 

 for i in [0, 1, 2, 3, 4, 5]: print(i**2) 

9.3 Циклы по спискам с индексами

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

 colors = ['red', 'green', 'blue', 'yellow'] for i, color in enumerate(colors): print(i, '-->', color) 

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)): print(i, '-->', colors[i]) 

9.4 Циклы по двум спискам

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

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] for name, color in zip(names, colors): print(name, '-->', color) 

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] n = min(len(names), len(colors)) for i in range(n): print(names[i], '-->', colors[i]) 

10. Импорты

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

 import os import sys 

 import sys, os 

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

 from subprocess import Popen, PIPE 

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

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

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

 import foo from foo import bar from foo.bar import baz from foo.bar import Quux from Foob import ar 

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

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

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

 from . import sibling from .sibling import example 

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

Рекомендуем также ознакомиться с полной версией соглашения о том, как писать код на Python (PEP 8)

Как писать питонический код: три рекомендации и три книги

Новички в Python часто спрашивают, как писать питонический код. Проблема — расплывчатое определение слова "питонический". Подробным материалом, в котором вы найдёте ответы на вопрос выше и три полезные книги, делимся к старту курса по Fullstack-разработке на Python.

Что значит «питонический»?

Python более 30 лет. За это время накоплен огромный опыт его применения в самых разных задачах. Этот опыт обобщался, и возникали лучшие практики, которые обычно называют «питоническим» кодом.

Философия Python раскрывается в The Zen of Python Тима Питерса, доступной в любом Python по команде import this в REPL:

>>> 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 больше всего раздражает красота Zen of Python. В Zen передаётся дух того, что значит «питонический» — и без явных советов. Вот первый принцип дзена Python: «Красивое лучше, чем уродливое». Согласен на 100%! Но как сделать красивым мой некрасивый код? Что это вообще такое — «красивый код»?

Сколь бы ни раздражала эта неоднозначность, именно она делает Zen of Python таким же актуальным, как и в 1999 году, когда Тим Питерс написал этот набор руководящих принципов. Они помогают понять, как отличать питонический и непитонический код, и дают ментальную основу принятия собственных решений.

Каким же будет определение слова «питонический»? Лучшее найденное мной определение взято из ответа на вопрос «Что означает «питонический» В этом ответе питонический код описывается так:

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

Из этого делаем два ключевых вывода:

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

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

1. Подружитесь с PEP8

PEP8 — это официальное руководство по стилю кода Python. PEP расшифровывается как Python Enhancement Proposal («Предложение по улучшению Python»). Это документы, предлагающие новые особенности языка. Они образуют официальную документацию особенности языка, принятие или отклонение которой обсуждается в сообществе Python. Следование PEP8 не сделает код абсолютно «питоническим», но способствует узнаваемости кода для многих Python-разработчиков.

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

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

# Correct seconds_per_hour = 3600 # Incorrect secondsperhour = 3600 secondsPerHour = 3600

Имена классов следует писать с прописными первыми буквами слов и без пробелов, вот так: CapitalizedWords:

# Correct class SomeThing: pass # Incorrect class something: pass class some_thing: pass

Константы записывайте в верхнем регистре и с подчёркиваниями между словами: UPPER_CASE_WITH_UNDERSCORES:

# Correct PLANCK_CONSTANT = 6.62607015e-34 # Incorrect planck_constant = 6.6260715e-34 planckConstant = 6.6260715e-34

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

Запоминать все соглашения PEP8 не нужно: найти и устранить проблемы PEP8 в коде могут помочь такие инструменты, как flake8. Установите flake8 с помощью pip:

# Linux/macOS $ python3 -m pip install flake8 # Windows $ python -m pip install flake8

flake8 можно использовать как приложение командной строки для просмотра файла Python на предмет нарушений стиля. Допустим, есть файл myscript.py с таким кодом:

def add( x, y ): return x+y num1=1 num2=2 print( add(num1,num2) )

При запуске на этом коде flake8 сообщает, как и где именно нарушается стиль:

$ flake8 myscript.py myscript.py:1:9: E201 whitespace after '(' myscript.py:1:11: E231 missing whitespace after ',' myscript.py:1:13: E202 whitespace before ')' myscript.py:4:1: E305 expected 2 blank lines after class or function definition, found 1 myscript.py:4:5: E225 missing whitespace around operator myscript.py:5:5: E225 missing whitespace around operator myscript.py:6:7: E201 whitespace after '(' myscript.py:6:16: E231 missing whitespace after ',' myscript.py:6:22: E202 whitespace before ')'

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

Для проверки качества кода с помощью flake8 вы даже можете настроить редакторы, например VS Code. Пока вы пишете код, он постоянно проверяется на нарушения PEP8. Когда обнаруживается проблема, во flake8 под частью кода с ошибкой появляется красная волнистая линия, найденные ошибки можно увидеть во вкладке встроенного терминала Problems:

flake8 — отличный инструмент для поиска связанных с нарушением PEP8 ошибок, но исправлять их придётся вручную. А значит, будет много работы. К счастью, весь процесс автоматизируемый. Автоматически форматировать код согласно PEP можно с помощью инструмента под названием Black.

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

Установите black c помощью pip:

# Linux/macOS $ python3 -m pip install black # Windows $ python -m pip install black

После установки командой black --check можно посмотреть, будут ли black изменять файл:

$ black --check myscript.py would reformat myscript.py Oh no! �� �� �� 1 file would be reformatted.

Чтобы увидеть разницу после изменений, используйте флаг --diff:

$ black --diff myscript.py --- myscript.py 2022-03-15 21:27:20.674809 +0000 +++ myscript.py 2022-03-15 21:28:27.357107 +0000 @@ -1,6 +1,7 @@ -def add( x, y ): - return x+y +def add(x, y): + return x + y -num1=1 -num2=2 -print( add(num1,num2) ) + +num1 = 1 +num2 = 2 +print(add(num1, num2)) would reformat myscript.py All done! ✨ �� ✨ 1 file would be reformatted.

Чтобы автоматически отформатировать файл, передайте его имя команде black:

$ black myscript.py reformatted myscript.py All done! ✨ �� ✨ 1 file reformatted. # Show the formatted file $ cat myscript.py def add(x, y): return x + y num1 = 1 num2 = 2 print(add(num1, num2))

Чтобы проверить совместимость с PEP8, снова запустите flake8 и посмотрите на вывод:

# No output from flake8 so everything is good! $ flake8 myscript.py

При работе с black следует иметь в виду, что максимальная длина строки по умолчанию в нём — это 88 символов. Это противоречит рекомендации PEP8 о 79 символах, поэтому при использовании black в отчёте flake8 вы увидете ошибки о длине строки.

Многие разработчики Python используют 88 знаков вместо 79, а некоторые — строки ещё длиннее. Можно настроить black на 79 символов, или flake8 — на строки большей длины.

Важно помнить, что PEP8 — это лишь набор рекомендаций, хотя многие программисты на Python относятся к ним серьёзно. PEP8 не применяется в обязательном порядке. Если в нём есть что-то, с чем вы категорически не согласны, вы вправе это игнорировать! Если же вы хотите строго придерживаться PEP8, инструменты типа flake8 и black сильно облегчат вам жизнь.

2. Избегайте циклов в стиле C

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

>>> names = ["JL", "Raffi", "Agnes", "Rios", "Elnor"] >>> # Using a `while` loop >>> i = 0 >>> while i < len(names): . print(names[i]) . i += 1 JL Raffi Agnes Rios Elnor >>> # Using a `for` loop >>> for i in range(len(names)): . print(names[i]) JL Raffi Agnes Rios Elnor

Вместо итерации можно перебрать все элементы списка сразу:

>>> for name in names: . print(name) JL Raffi Agnes Rios Elnor

Этим вторая рекомендация не ограничивается: она намного глубже простого перебора элементов списка. Такие идиомы Python, как списковые включения, встроенные функции (min(), max() и sum()) и методы объектов, может помочь вывести ваш код на новый уровень.

Отдавайте предпочтение списковым включениям, а не простым циклам for

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

>>> nums = [1, 2, 3, 4, 5] >>> squares = [] >>> for num in nums: . squares.append(num ** 2) . >>> squares [1, 4, 9, 16, 25]

Но более питонически применить списковое включение:

>>> squares = [num ** 2 for num in nums] # >> squares [1, 4, 9, 16, 25]

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

Вот так я обычно пишу списковые включения:

1. Начинаю с создания литерала пустого списка:
   [].
2. Первым в списковое включение помещаю то, что обычно идёт в метод .append()при создании списка с помощью цикла for:
   [num ** 2].
3. И, наконец, помещаю в конец списка заголовок цикла for:
   [num ** 2 for num in nums].

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

Используйте встроенные функции, такие как min(), max() и sum()

Ещё одна типичная задача программирования — это поиск минимального или максимального значения в массиве чисел. Найти наименьшее число в списке можно с помощью for:

>>> nums = [10, 21, 7, -2, -5, 13] >>> min_value = nums[0] >>> for num in nums[1:]: . if num < min_value: . min_value = num . >>> min_value -5

Но более «питонически» применять встроенную функцию min():

>>> min(nums) -5

То же касается нахождения наибольшего значения в списке: вместо цикла применяется встроенная функция max():

>>> max(nums) 21

Чтобы найти сумму чисел списка, написать цикл for можно, но более питонически воспользоваться sum():

>>> # Not Pythonic: Use a `for` loop >>> sum_of_nums = 0 >>> for num in nums: . sum_of_nums += num . >>> sum_of_nums 44 >>> # Pythonic: Use `sum()` >>> sum(nums) 44

Также sum() полезна при подсчёте количества элементов списка, для которых выполняется некое условие. Например, вот цикл for для подсчёта числа начинающихся с буквы A строк списка:

>>> capitals = ["Atlanta", "Houston", "Denver", "Augusta"] >>> count_a_capitals = 0 >>> for capital in capitals: . if capital.startswith("A"): . count_a_capitals += 1 . >>> count_a_capitals 2

Функция sum() со списковым включением сокращает цикл for до одной строки:

>>> sum([capital.startswith("A") for capital in capitals]) 2

Красота! Но ещё более питонической эту строку сделает замена спискового включения на выражение-генератор. Убираем скобки списка:

>>> sum(capital.startswith("A") for capital in capitals) 2

Как именно работает код? И списковое включение, и выражение-генератор возвращают итерируемый объект со значением True, если строка в списке capitals начинается с буквы A, и False — если это не так:

>>> [capital.startswith("A") for capital in capitals] [True, False, False, True]

В Python True и False — это завуалированные целые числа. True равно 1, а False — 0:

>>> isinstance(True, int) True >>> True == 1 True >>> isinstance(False, int) True >>> False == 0 True

Когда в sum() передаётся списковое включение или выражение-генератор, значения True и False считаются 1 и 0 соответственно. Всего два значения True и два False, поэтому сумма равна 2.

Использование sum() для подсчёта числа удовлетворяющих какому-то условию элементов списка подчёркивает важность понятия «питонический». Я нахожу такое применение sum() очень питонически. Ведь с sum() используется несколько особенностей этого языка и создаётся, на мой взгляд, лаконичный и удобный для восприятия код. Но, возможно, не каждый разработчик на Python со мной согласится.

Можно было бы возразить, что в этом примере нарушается один из принципов Zen of Python: «Явное лучше неявного». Ведь не очевидно, что True и False — целые числа и что sum() вообще должна работать со списком значений True и False. Чтобы освоить это применение sum(), нужно глубоко понимать встроенные типы Python.

Узнать больше о True и False как целых числах, а также о других неожиданных фактах о числах в Python можно из статьи 3 Things You Might Not Know About Numbers in Python («3 факта о числах в Python, которых вы могли не знать»).

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

3. Используйте правильную структуру данных

Большая роль при написании чистого, питонического кода для конкретной задачи отводится выбору подходящей структуры данных. Python называют языком «с батарейками в комплекте». Некоторые батарейки из комплекта Python — это эффективные, готовые к применению структуры данных.

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

Вот CSV-файл clients.csv с данными по клиентам:

first_name,last_name,email,phone Manuel,Wilson,mwilson@example.net,757-942-0588 Stephanie,Gonzales,sellis@example.com,385-474-4769 Cory,Ali,coryali17@example.net,810-361-3885 Adam,Soto,adams23@example.com,724-603-5463

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

Используя объект DictReader из модуля csv, можно прочитать каждую строку файла как словарь:

>>> import csv >>> with open("clients.csv", "r") as csvfile: . clients = list(csv.DictReader(csvfile)) . >>> clients [, , , ]

clients — это список словарей. Поэтому, чтобы найти клиента по адресу почты, например sellis@example.com, нужно перебрать список и сравнить почту каждого клиента с целевой почтой, пока не будет найден нужный клиент:

>>> target = "sellis@example.com" >>> phone = None >>> for client in clients: . if client["email"] == target: . phone = client["phone"] . break . >>> print(phone) 385-474-4769

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

Более питонически сопоставить клиентов с их почтами, а не хранить клиентов в списке. Для этого отлично подойдёт словарное включение:

>>> with open("clients.csv", "r") as csvfile: . # Use a `dict` comprehension instead of a `list` . clients = . >>> clients

Словарные включения очень похожи на списковые включения:

1. Я начинаю с создания пустого словаря:
   <>.
2. Затем помещаю туда разделённую двоеточием пару «ключ — значение»:
   .
3. И пишу выражение с for, которое перебирает все строки в CSV:
   .

Вот это словарное включение, преобразованное в цикл for:

>>> clients = <> >>> with open("clients.csv", "r") as csvfile: . for row in csv.DictReader(csvfile): . clients[row["email"]] = row["phone"]

С этим словарём clients вы можете найти телефон клиента по его почте без циклов:

>>> target = "sellis@example.com" >>> clients[target] 385-474-4769

Этот код не только короче, но и намного эффективнее перебора списка циклом. Но есть проблема: если в clients нет клиента с искомой почтой, поднимается ошибка KeyError:

>>> clients["tsanchez@example.com"] Traceback (most recent call last): File "", line 1, in KeyError: 'tsanchez@example.com'

Поэтому, если клиент не найден, можно перехватить KeyError и вывести значение по умолчанию:

>>> target = "tsanchez@example.com" >>> try: . phone = clients[target] . except KeyError: . phone = None . >>> print(phone) None

Но более питонически применять метод словаря .get(). Если пара с ключом существует, этот метод возвращает значение пары, иначе возвращается None:

>>> clients.get("sellis@example.com") '385-474-4769'

Сравним решения выше:

import csv target = "sellis@example.com" phone = None # Un-Pythonic: loop over a list with open("clients.csv", "r") as csvfile: clients = list(csv.DictReader(csvfile)) for client in clients: if client["email"] == target: phone = client["phone"] break print(phone) # Pythonic: lookup in a dictionary with open("clients.csv", "r") as csvfile: clients = phone = clients.get(target) print(phone)

Питонический код короче, эффективнее и не менее удобен для восприятия.

Используйте операции над множествами

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

>>> nums = [1, 3, 2, 3, 1, 2, 3, 1, 2] >>> unique_nums = list(set(nums)) >>> unique_nums [1, 2, 3]

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

Вот придуманный, но реалистичный пример. У владельца магазина есть CSV-файл клиентов с адресами их почты. Снова возьмём файл clients.csv. Есть также CSV-файл заказов за последний месяц orders.csv, тоже с адресами почты:

date,email,items_ordered 2022/03/01,adams23@example.net,2 2022/03/04,sellis@example.com,3 2022/03/07,adams23@example.net,1

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

>>> import csv >>> # Create a list of all client emails >>> with open("clients.csv", "r") as clients_csv: . client_emails = [row["email"] for row in csv.DictReader(clients_csv)] . >>> # Create a list of emails from orders >>> with open("orders.csv") as orders_csv: . order_emails = [row["email"] for row in csv.DictReader(orders_csv)] . >>> # Use a list comprehension to filter the clients emails >>> coupon_emails = [email for email in clients_emails if email not in order_emails] >>> coupon_emails ["mwilson@example.net", "coryali17@example.net"]

Код нормальный и выглядит вполне питонически. Но что, если каждый месяц клиентов и заказов будут миллионы? Тогда при фильтрации почты и определении, каким клиентам отправлять купоны, потребуется перебор всего списка client_emails. А если в файлах client.csv и orders.csv есть повторяющиеся строки? Бывает и такое.

Более питонически считать адреса почты клиентов и заказов в множествах и отфильтровать множества почтовых адресов клиентов оператором разности множеств:

>>> import csv >>> # Create a set of all client emails using a set comprehension >>> with open("clients.csv", "r") as clients_csv: . client_emails = . >>> # Create a set of emails frp, orders using a set comprehension >>> with open("orders.csv", "r") as orders_csv: . order_emails = . >>> # Filter the client emails using set difference >>> coupon_emails = client_emails - order_emails >>> coupon_emails

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

Три книги, чтобы писать более питонический код

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

Если вы новичок в Python (и тем более в программировании в целом), загляните в мою книгу Python Basics: A Practical Introduction to Python 3 («Основы Python: Практическое введение в Python 3»).

Python Tricks Дэна Бейдера

Короткая и приятная книга Дэна Бейдера Python Tricks: A Buffet of Awesome Python Features («Приёмы Python: набор потрясающих функций Python») — отличная отправная точка для начинающих и программистов, желающих больше узнать о том, как писать питонический код.

С Python Tricks вы изучите шаблоны написания чистого идиоматичного кода Python, лучшие практики для написания функций, эффективное применение функционала объектно-ориентированного программирования Python и многое другое.

Effective Python Бретта Слаткина

Effective Python («Эффективный Python») Бретта Слаткина — это первая книга, которую я прочитал после изучения синтаксиса Python. Она открыла мне глаза на возможности питонического кода.

В Effective Python содержится 90 способов улучшения кода Python. Одна только первая глава Python Thinking («Мыслить на Python») — это кладезь хитростей и приёмов, которые будут полезными даже для новичков, хотя остальная часть книги может быть для них трудной.

Fluent Python Лучано Рамальо

Если бы у меня была только одна книга о Python, это была бы книга Лучано Рамальо Fluent Python («Python. К вершинам мастерства»). Рамальо недавно обновил свою книгу до современного Python. Сейчас можно оформить предзаказ. Настоятельно рекомендую сделать это: первое издание устарело.

Полная практических примеров, чётко изложенная книга Fluent Python — отличное руководство для всех, кто хочет научиться писать питонический код. Но имейте в виду, что Fluent Python не предназначена для новичков. В предисловии к книге написано:

«Если вы только изучаете Python, эта книга будет трудной для вас».

У вас может сложиться впечатление, что в каждом скрипте на Python должны использоваться специальные методы и приёмы метапрограммирования. Преждевременная абстракция так же плоха, как и преждевременная оптимизация.

Опытные программисты на Python извлекут из этой книги большую пользу.

А мы поможем вам прокачать скиллы или с самого начала освоить профессию в IT, актуальную в любое время:

• Профессия Fullstack-разработчик на Python
• Профессия Data Scientist

Краткий каталог курсов и профессий

Data Science и Machine Learning

• Профессия Data Scientist
• Профессия Data Analyst
• Курс «Математика для Data Science»
• Курс «Математика и Machine Learning для Data Science»
• Курс по Data Engineering
• Курс «Machine Learning и Deep Learning»
• Курс по Machine Learning

Python, веб-разработка

• Профессия Fullstack-разработчик на Python
• Курс «Python для веб-разработки»
• Профессия Frontend-разработчик
• Профессия Веб-разработчик

Мобильная разработка

• Профессия iOS-разработчик
• Профессия Android-разработчик

Java и C#

• Профессия Java-разработчик
• Профессия QA-инженер на JAVA
• Профессия C#-разработчик
• Профессия Разработчик игр на Unity

От основ — в глубину

• Курс «Алгоритмы и структуры данных»
• Профессия C++ разработчик
• Профессия Этичный хакер

А также

Пишем программу на Python с помощью ChatGPT

Представим ситуацию: мы не умеем программировать на Python, но знаем, что ChatGPT умеет. Наша задача — не написав самим ни одной строчки кода, создать код, который будет делать что-то полезное. Всё, что мы можем делать — это отправлять запросы в чат, брать оттуда код и смотреть на результат. Заодно узнаем, получится ли так программировать или нет.

Что делаем

Мы попросим ChatGPT написать код, который угадает число от 1 до 100 за 7 попыток. В «Коде» мы уже писали про эту задачу и про алгоритм её решения, поэтому будем сверяться с ним.

Для решения используем сервис Chad — внутри ChatGPT 3.5 и 4 на выбор, работает в России без ВПН и понимает русский язык.

Первый подход: код есть, но не работает

Открываем Chad и выбираем режим для разработчиков, который посередине:

Пишем запрос в самой простой форме, указывая только ключевые моменты:

Напиши программу на Python, которая угадывает число, которое загадал пользователь от 1 до 100 за 7 попыток или меньше.

В ответ сервис даёт код и поясняет, что он делает: как будет работать и для чего нужна определённая переменная:

import random def guess_number(start, end, max_attempts): print(f"Загадайте число от до . Я попытаюсь его угадать за попыток или меньше.") low = start high = end for attempt in range(1, max_attempts + 1): guess = random.randint(low, high) print(f"Попытка #: Я думаю, это число .") if guess == user_number: print("Ура! Я угадал число!") return elif guess < user_number: print("Мое число слишком маленькое.") low = guess + 1 else: print("Мое число слишком большое.") high = guess - 1 print("К сожалению, я не смог угадать число за заданное количество попыток.") user_number = random.randint(1, 100) # Пользователь загадывает число от 1 до 100 guess_number(1, 100, 7)

Но при запуске этого кода мы получаем странный результат — программа моментально проходит 7 попыток и сообщает, что ничего не угадала:

Второй подход: исправляем ошибку

Раз компьютер не отгадал число за 7 попыток, значит, с алгоритмом явно что-то не так. Просим объяснить, что происходит в программе:

Прокомментируй в этом коде каждую строку

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

1. `import random` - импорт модуля random, который позволяет нам генерировать случайные числа.

2. `def guess_number(start, end, max_attempts):` - определение функции с именем `guess_number`, которая принимает три аргумента: `start` (начальное значение диапазона чисел), `end` (конечное значение диапазона чисел) и `max_attempts` (максимальное количество попыток).

3. `print(f"Загадайте число от до . Я попытаюсь его угадать за попыток или меньше.")` - выводит сообщение с использованием значений `start`, `end` и `max_attempts` для подсказки пользователю о правилах игры.

4. `low = start` - присваивает переменной `low` значение `start`. Переменная `low` будет использоваться для хранения текущего нижнего значения диапазона.

5. `high = end` - присваивает переменной `high` значение `end`. Переменная `high` будет использоваться для хранения текущего верхнего значения диапазона.

6. `for attempt in range(1, max_attempts + 1):` - начинает цикл, который будет выполняться `max_attempts` раз. Переменная `attempt` будет принимать значения от 1 до `max_attempts`.

7. `guess = random.randint(low, high)` - генерирует случайное число в диапазоне от `low` до `high` и присваивает его переменной `guess`. Это предполагаемое число, которое попытается угадать компьютер

8. `print(f"Попытка #: Я думаю, это число .")` - выводит сообщение с использованием текущего значения `attempt` и `guess` для показа предполагаемого числа компьютера.

9. `if guess == user_number:` - проверяет, равно ли предполагаемое число `guess` загаданному пользователем числу `user_number`.

10. `print("Ура! Я угадал число!")` - выводит сообщение, если компьютер угадал число пользователя.

11. `return` - прерывает выполнение функции и возвращает управление обратно в основную программу.

13. `print("Мое число слишком маленькое.")` - выводит сообщение, если предполагаемое число `guess` слишком маленькое.

14. `low = guess + 1` - присваивает переменной `low` значение `guess + 1`, чтобы ограничить будущие предполагаемые числа в большем диапазоне.

15. `else:` - выполняется, если ни одно из предыдущих условий не выполнилось, что означает, что `guess` больше, чем `user_number`.

16. `print("Мое число слишком большое.")` - выводит сообщение, если предполагаемое число `guess` слишком большое.

17. `high = guess - 1` - присваивает переменной `high` значение `guess - 1`, чтобы ограничить будущие предполагаемые числа в меньшем диапазоне.

18. `print("К сожалению, я не смог угадать число за заданное количество попыток.")` - выводит сообщение, если компьютер не смог угадать число в заданное количество попыток.

19. `user_number = random.randint(1, 100)` - генерирует случайное число от 1 до 100 и присваивает его переменной `user_number`. Это число, которое пользователь должен загадать.

20. `guess_number(1, 100, 7)` - вызывает функцию `guess_number` с аргументами `1`, `100` и `7`. Это начинает игру, где пользователь должен загадать число от 1 до 100, а компьютер будет пытаться угадать за 7 попыток или меньше.

Ага, значит, значение переменной guess, которая отвечает за очередную попытку угадать число, выбирается случайным образом (точно так же, как это делает user_number ). Но в теоретическом решении написано, что нужно взять диапазон и поделить его пополам. Значит, нам нужно попросить исправить код, чтобы диапазон делился пополам:

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

Вот что получили в ответ:

Понимаю, извините за путаницу. Вот исправленный код, который выполняет угадывание числа путем деления диапазона пополам.
В этом обновленном коде используется метод деления диапазона пополам для каждой попытки. Вместо случайного числа, программе необходимо определить середину текущего диапазона (guess = (low + high) // 2).
После предложения числа пользователь проверяет ответ и сообщает программе, является ли загаданное число больше или меньше предложенного числа. Затем диапазон обновляется путем изменения нижней или верхней границы в зависимости от ответа пользователя.

def guess_number(start, end, max_attempts): print(f"Загадайте число от до . Я попытаюсь его угадать за попыток или меньше.") low = start high = end for attempt in range(1, max_attempts + 1): guess = (low + high) // 2 print(f"Попытка #: Я думаю, это число .") if guess == user_number: print("Ура! Я угадал число!") return elif guess < user_number: print("Мое число слишком маленькое.") low = guess + 1 else: print("Мое число слишком большое.") high = guess - 1 print("К сожалению, я не смог угадать число за заданное количество попыток.") user_number = random.randint(1, 100) # Пользователь загадывает число от 1 до 100 guess_number(1, 100, 7)

Копируем, вставляем в редактор кода, запускаем — и получаем ошибку NameError: name 'random' is not defined . Спрашиваем, что с ней делать:

Что означает ошибка NameError: name 'random' is not defined и как её исправить

Вот что предлагает ChatGPT:

Ошибка NameError: name 'random' is not defined возникает, когда пытаемся использовать имя, которое не было определено или импортировано в текущей области видимости.

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

Чтобы исправить эту проблему, в начале программы добавьте строку import random. Это позволит использовать функции и классы из модуля random.

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

Теперь код угадывает любое число до 100 за 7 попыток или меньше, но есть проблема — здесь нет взаимодействия с пользователем, в эту игру неинтересно играть, когда компьютер сам загадывает и сам угадывает числа.

Третий подход: добавляем интерактив

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

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

Вот что получаем в ответ:

В этой версии кода после предложения ввести число пользователь будет приглашен ввести загаданное число, с которым программа будет пытаться угадать. Загаданное число сохраняется в переменную user_number в виде целого числа с помощью функции int(input()).

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

def guess_number(start, end, max_attempts): print(f"Загадайте число от до . Я попытаюсь его угадать за попыток или меньше.") low = start high = end user_number = int(input("Введите загаданное число: ")) for attempt in range(1, max_attempts + 1): guess = (low + high) // 2 print(f"Попытка #: Я думаю, это число .") if guess == user_number: print("Ура! Я угадал число!") return elif guess < user_number: print("Мое число слишком маленькое.") low = guess + 1 else: print("Мое число слишком большое.") high = guess - 1 print("К сожалению, я не смог угадать число за заданное количество попыток.") guess_number(1, 100, 7)

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

Четвёртый подход: добавляем ответы игрока

Улучшаем код и пишем такой запрос:

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

Сервис сразу меняет код и даёт большое пояснение, как что внутри работает:

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

На каждой итерации цикла программа предлагает свой вариант с помощью переменной guess, затем ожидает ввода пользователя с помощью input(). Ввод пользователя сохраняется в переменную user_input.

Затем, в зависимости от ответа пользователя, программе сообщается об изменении диапазона для следующей попытки. Если число пользователя больше предложенного, мы обновляем нижнюю границу, увеличивая ее на 1 (low = guess + 1). Если число пользователя меньше предложенного, обновляем верхнюю границу, уменьшая ее на 1 (high = guess - 1). Если число пользователя равно предложенному, программа завершается.

def guess_number(start, end): print(f"Загадайте число от до . Я попытаюсь его угадать.") low = start high = end while True: guess = (low + high) // 2 print(f"Я думаю, это число .") user_input = input("Ваше число больше (>), меньше (<) или равно (=) предложенному? ") if user_input == '>': low = guess + 1 elif user_input == '

def guess_number(start, end): print(f"Загадайте число от до . Я попытаюсь его угадать.") low = start high = end attempts = 0 while True: guess = (low + high) // 2 attempts += 1 print(f"Попытка #: Я думаю, это число .") user_input = input("Ваше число больше (>), меньше (<) или равно (=) предложенному? ") if user_input == '>': low = guess + 1 elif user_input == ' <': high = guess - 1 elif user_input == '=': print(f"Ура! Я угадал число за попыток!") return else: print("Некорректный ввод. Попробуйте снова.") print("К сожалению, я не смог угадать число.") guess_number(1, 100)

from termcolor import colored def guess_number(start, end): print(f"Загадайте число от до . Я попытаюсь его угадать.") low = start high = end attempts = 0 while True: guess = (low + high) // 2 attempts += 1 print(colored(f"Попытка #: Я думаю, это число .", 'green')) user_input = input("Ваше число больше (>), меньше (<) или равно (=) предложенному? ") if user_input == '>': low = guess + 1 elif user_input == ' <': high = guess - 1 elif user_input == '=': print(colored(f"Ура! Я угадал число за попыток!", 'blue')) return else: print("Некорректный ввод. Попробуйте снова.") print("К сожалению, я не смог угадать число.") guess_number(1, 100)