как писать красивый код на python

22 полезных примера кода на Python

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

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

1. Получаем гласные

2. Первая буква в верхнем регистре

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

3. Печать строки N раз

Этот пример может печатать любую строку n раз без использования циклов Python.

4. Объединяем два словаря

Этот пример выполняет слияние двух словарей в один.

5. Вычисляем время выполнения

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

6. Обмен значений между переменными

Это быстрый способ обменять местами две переменные без использования третьей.

7. Проверка дубликатов

Это самый быстрый способ проверки наличия повторяющихся значений в списке.

8. Фильтрация значений False

9. Размер в байтах

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

10. Занятая память

Пример позволяет получить объём памяти, используемой любой переменной в Python.

11. Анаграммы

Этот код полезен для проверки того, является ли строка анаграммой. Анаграмма — это слово, полученное перестановкой букв другого слова.

12. Сортировка списка

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

13. Сортировка словаря

14. Получение последнего элемента списка

15. Преобразование разделённого запятыми списка в строку

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

16. Проверка палиндромов

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

17. Перемешивание списка

18. Преобразование строки в нижний и верхний регистры

19. Форматирование строки

Этот код позволяет форматировать строку. Под форматированием в Python подразумевается присоединение к строке данных из переменных.

20. Поиск подстроки

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

21. Печать в одной строке

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

22. Разбиение на фрагменты

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

На правах рекламы

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

Источник

Python & EEL. Делаем просто на Python’е и красиво на JS

Вступление

Тема красивых интерфейсов была и будет актуальна всегда. Кто-то использует для создания графических приложений C#, кто-то использует Java, кто-то уходит в дебри C++, ну а кто-то извращается с Python, используя tkinter или PyQT. Существуют различные технологии, позволяющие совмещать красоту графических дизайнов, создаваемых на HTML, CSS и JS с гибкостью в реализации логики приложения, которую может дать другой язык. Так вот, для тех, кто пишет на самом лучшем языке программирования Python, есть возможность писать красивые интерфейсы на HTML, CSS и JS и прикручивать к ним логику на Python.

В этой статья я хочу показать на небольшом примере, как же все таки создать простое и красивое десктопное приложение на HTML, CSS, JS и Python. В качестве библиотеки для связи всех компонентов будем использовать EEL.

Установка

Оговорюсь, что я работаю на windows 10 x64.

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

Наше приложение будет выглядеть таким образом:

Логика приложения очень простая: при нажатии кнопки “рассчитать” считываются значения в поле для ввода рублей, полученные данные отправляются в Python, где происходит расчет курса валют. Python возвращает нам данные и мы выводим из через JS

Раскидываем по папкам

Разобьем теперь наш проект на модули. В папку “front” будем класть всё, что связано с графической частью нашего приложения. В папку “back” будем помещать все наши исходники на python. Еще создадим папку middle, в которую будем помещать методы, вызываемые из JS (об этом чуть позже). В Главной директории создадим файл main.py, он будет запускать наше приложение.

Логика на Python

В качестве теста реализуем простое приложение конвертер валют (да-да, банально, никому не надо, на гитхабе миллион проектов). Для этого на python установим библиотеку CurrencyConverter:
pip install currencyconverter

Теперь приступим к написанию логики на python. Реализуем метод, который на вход будет принимать сумму, валюту с которой нам надо перевести и валюту, на которую нам надо перевести. Создадим “convert.py” в директории “back” и запишем в него следующий код:

Теперь в директории “middle” создадим файл “mid_convert.py” и пропишем следующий код:

Что здесь вообще происходит? Файл “mid_convert.py” будет служит связующим звеном между JS и Python. Декоратор @eel.expose дает нашей программе понять, что функция, описанная ниже, может быть вызвана из JS. Таким образом, любая функция, которую мы в будущем захотим вызывать из JS, должна быть обернута декоратором @eel.expose. Очевидно, что не имеет смысла делать лишних модулей, если у вас простой проект, можно было обернуть декоратором функцию “convert_value” в модуле “convert.py”. В больших проектах разбиение программы на такие слои позволит легче расширять и оптимизировать код.

Подключаем Python к JS

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

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

Обратите внимание на строку “let value_cur = await eel.convert_value_py(value_rub, «RUB», name_cur)();”. Важно, что вызов функции из питона происходит в асинхронном режиме, поэтому обязательно необходимо сделать асинхронной ту функцию, в которой есть вызов Python кода. При вызове функции из eel необходимо ставить пару (), где в первые круглые скобки будут передаваться наши аргументы.

Проверим, работает ли.

Как мы видим, все работает.

Запуск программы

Для запуска кода используем файл “main.py”. В нем импортируем библиотеку eel и всё, что мы писали в файле “min_convert.py” для того, чтобы при запуске проекта подтянуть все функции, которые мы оборачивали в eel.expose:

Теперь необходимо проинициализировать через eel ту директорию, где лежит front-end нашего приложения. При помощи команды eel.init(args). Далее для запуска самого приложения вызывает метод eel.start(args):

Метод eel.start принимает на вход несколько параметров (подробнее о них см. официальную документацию по eel). Самым интересным параметром является “mode”. При помощи него вы можете запустить свой проект, как в браузере, так и в виде отдельного приложения. Например, вы можете указать параметр “default”, в таком случае приложению будет запускать в браузере по умолчанию. Если у вас стоит google chrome, то указав параметр “mode=chrome” ваша программа откроется в виде отдельного приложения.

Также можно использовать chromium. Для этого скачиваем его с официального сайта. Разархивируем его в какую-нибудь папку и прописываем следующий код в нашем “main.py”:

Вывод

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

Источник

PEP 8: каким должен быть код на Python

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

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

Почему важно стандартизировать код?

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

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

Рекомендации по созданию красивого кода на Python не определяют стиль кода полностью. Поэтому программист может делать некоторые вещи на своё усмотрение, однако он всё ещё должен следовать тем указаниям, которые определены в стандарте.

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

Разметка кода на Python

Этот раздел содержит указания, определяющие, как оформлять код на Python 3 (пробелы, отступы, строки).

Отступы

Для обозначения нового уровня вложенности используется четыре пробела.

При разделении аргументов функции на несколько строк размер отступа может быть разным.

Если это объявление или вызов функций (нет тела функции), то можно либо выравнивать следующие строки по открывающейся скобке:

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

Если после списка аргументов следует еще какой-либо код (например, если это объявляется функция), то к отступу аргументов добавляется еще 4 пробела:

Это делается для того, чтобы отделить аргументы от тела функции.

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

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

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

Также её можно поместить в самое начало строки:

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

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

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

Круглые скобки — лучший способ реализовать разделение кода на несколько строк. Однако программисты также могут использовать знак обратной косой черты « \ «.

Бинарные операторы и пробелы

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

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

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

Методы внутри класса отделяются одной пустой строкой.

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

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

Кодировка

Если нужно использовать символы других кодировок, следует пользоваться экранирующими последовательностями: \x, \u, \U, \N.

Импорт

Импорт каждого нового модуля должен происходить в новой строке:

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

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

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

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

Кавычки в строках

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

Для строк документации обязательно используется три двойных кавычки. Более подробнее это описано в стандарте PEP 257.

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

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

Использование запятых

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

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

Комментарии

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

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

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

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

Блочные комментарии

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

Комментарии «в строке»

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

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

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

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

Все открытые модули, функции, классы и их составляющие должны документироваться. Это правило не относится к приватным методам, однако между строкой с «def» и телом метода можно написать комментарий, который описывает назначение метода.

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

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

Правила по выбору имён

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

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

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

Стили имен

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

Обычно используются следующие стили:

Имена, которые лучше не использовать

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

Если всё же возникла необходимость использовать l («эл»), замените её на заглавную «L».

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

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

Если модуль на C или C++ сопровождается модулем Python, обеспечивающим более высокоуровневый интерфейс, то имя C/C++ модуля начинается с символа нижнего подчеркивания (_modulename).

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

Классам дают имена в соответствии со стилем наименования CapitalizedWords.

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

Из-за того что исключения по сути являются классами, к ним применяется то же соглашение об наименованиях, что и для классов.

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

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

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

__all__ — это список доступных для импорта объектов, то есть публичных.

Имена функций и переменных

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

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

В случаях, если требуется сохранить обратную совместимость с библиотекой (например, threading.py), допускается использовать mixedCase.

Имена аргументов функций и методов

Для методов экземпляра в качестве первого аргумента всегда используется self, а для методов класса — cls.

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

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

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

Константы

Константы определяются на уровне подключения модулей и пишутся в верхнем регистре с разделением слова символами подчеркивания.

Источник

Пишем красивый идиоматический Python

Иногда сложно найти в Сети правильные, а главное актуальные «best practices» для языка. Документация, конечно же, содержит всю необходимую информацию, но отсеять нужную вещь в абзацах подробного (на то она и документация) описания довольно сложно. Но недавно мне улыбнулся поиск Google, и я наткнулся на очень полезные «паттерны» языка Python от одного из core разработчиков — Raymond Hettinger.

Примечание: Все рекомендации даны в нескольких вариантах: сначала идут самые «плохие» варианты, а дальше предлагается лучшая альтернатива. Актуально для версии языка 2.7, отличия для версии 3.3 читайте в примечаниях к конкретному «паттерну».

Цикл по массиву из чисел

Плохо: иногда пишут так.

Хорошо: лучший, с генератором. Но в 32 битной системе список из миллиона чисел будет занимать

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

Цикл по списку

Плохо: часто бывшие С программисты пишут так.

Хорошо: лучший вариант.

Но если нужно пройти по списку задом на перед?

Плохо: опять, прошло из C дает о себе знать:

Хорошо: но в Python пишут вот так:

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

Плохо тоже что и выше.

Хорошо: более элегантный вариант:

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

Плохо тоже что и выше.

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

Сортировка списка по алгоритму

Плохо: используя функцию для сравнения.

Хорошо: используя сортировку по ключу. Использует намного меньше памяти.

Примечание: Метод cmp убран с ядра Python 3.x.

Цикл по ключам словаря

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

Для изменения словаря в цикле используйте цикл по ключам (Пример: удаление всех ключей начинающихся с R ):

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

Цикл по ключам и значением словаря

Плохо: цикл по ключам и возвращение значение по последним. Медленный способ:

Хорошо: быстрее делать цикл по значениях:

Отлично: Но самый лучший и быстрый способ это использовать итератор:

Соединение двух списков в один словарь

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

Подсчет элементов в словаре

Плохо: обычный способ:

Хорошо: использует функцию get() :

Группирование элементов списка

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

Хорошо: но есть способ гораздо элегантней и быстрее:

На сегодня все. Надеюсь эти тривиальные, но полезные примеры помогут кому-то улучшить свой код, как они помогли это сделать мне. Их автором является Raymond Hettinger (@raymondh), Python Core Developer.

Источник

Пишем на Питоне сразу хорошо

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

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

Early quit

Это точно на первом месте, потому что везде, у всех я это вижу:

Мы могли бы поменять условия местами:

Это легче читается, так как случай not a мы уже рассмотрели и выкинули из головы в самом начале. Но если присмотреться, то else вообще не нужен:

Вот синтетический пример для какого-то парсинга:

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

One-line assignment

Поговорим о присваивании переменных. Часто я вижу такое:

не факт, что вы не забыли рассмотреть ещё какой-то случай

можно банально опечататься при копи-пасте (если вы копируете случаи и заменяете значения), и в разных случаях присвоить одно и то же значение

Какой же выход? Старайтесь определять переменные один раз. В идеале любое объявление переменной должно выглядеть так:

И не более того. Я намеренно пишу «в идеале», потому что не всегда это возможно сделать, а где-то от этого страдает читаемость кода, так что нужно делать с умом.

В случае выше я бы заменил код на

Definition close to usage

Ещё один способ разгрузить память программиста. Часто вижу такое:

С этой проблемой и борется этот паттерн: мы определяем переменные наиболее близко к тому месту, где мы их будем использовать. Как только вы хотите создать переменную, спросите себя: «нужна ли эта переменная в следующем сниппете кода»? Если нет, то, возможно, её следует определить позднее. Таким образом при анализе кода вы сможете бросить взгляд на соседние строчки кода и понять, откуда взялись эти переменные и что в них.

В примере выше мы просто двигаем fields именно туда, где они используются, и даже можем заинлайнить их прям в for :

Too many indents

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

Частным случаем этого являются двойные, тройные и т.д. циклы, вроде

Такие штуки часто можно упростить при помощи itertools и функций, например

Dangerous loops

Поэтому просто что-нибудь, что кончается:

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

Copy-paste more than twice

Interconnected lines of code

Type hints

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

Quick «in» check

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

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

Пишете SQL запрос? Делайте джойны, как будто у вас миллион записей в каждой таблице.

Пишете view для Джанго? Пишите его так, как будто его будут вызывать миллионы пользователей.

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

Concurrency safety

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

Возможно, ничего. Возможно, ничего хорошего.

Asserts everywhere

Ожидаете определённые данные с внешнего сервиса? Ставьте ассерт:

Написали код, который сами не понимаете? Ставьте ассерт:

К чему всё это

Источник