Python — один из самых универсальных языков: его используют в своих продуктах топовые IT-компании, включая Microsoft, Google, Facebook и Yandex. В то же время Python часто выбирают новички, потому что язык имеет простой синтаксис и в целом лаконичен.

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

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

Web Разработка

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

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

Ресурсы для изучения:

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

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

Мега-учебник по Flask — онлайн-учебник Мигеля Гринберга всегда был мастхэв ресурсов для тех, кто изучал Flask. И вот на Хабре сделали полный перевод всех его туториалов.

Канал Олега Молчанова — одних из лучших авторов по Python на русскоязычном YouTube. У него на канале есть плейлисты и по Flask, и по Django, в которых сразу начинается создание практических проектов.

Машинное обучение

В Python есть разнообразные модули, позволяющие быстро создавать производительные скрипты в области машинного обучения. Например, Scikit-learn отличается тем, что в него уже встроены самые распространенные алгоритмы обучения. TensorFlow, в свою очередь — это низкоуровневая библиотека, которая открывает возможности для создания алгоритмов пользователя.

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

Ресурсы для изучения:

Введение в машинное обучение — совместный курс от ВШЭ и Школы Анализа Данных от Яндекса. Один из лучших вариантов на русском языке.

Машинное обучение от Andrew Ng — полный курс по ML от ведущего преподавателя из Стэнфорда, отличный вариантов для новичков. Кстати, на этот курс записались уже более 4 миллионов человек.

Глубокое обучение от Andrew Ng — курс от того же топового преподавателя, но уже конкретно по глубокому обучению, а не ML в целом.

Анализ данных

Решения в сфере Big Data и Business Analytic приносят сотни миллиардов каждый год, и доходы постоянно растет. А популярность отрасли постоянно растет. В 2015 только 17% компаний использовали возможности аналитики Big Data, а в 2017 это значение выросло до 53%.

Сбор, обработка и визуализация — 3 самых популярных сценария использования Python для анализа данных.

Ресурсы для изучения:

Статистика и вероятность — мастхэв курс от Khan Academy, который даст весь необходимый теоретический минимум.

Математика и Python для анализа данных — хороший вводный курс от МФТИ и Яндекса, в котором будут разбираться необходимая математика и инструменты для работы с данными.

Введение в реляционные базы данных — курс от Udacity дает краткое, но вполне достаточное для начала работы представление о базах данных, подобных SQL.

Заключение

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

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

Подводя итоги, можно сказать, что Django — лучший вариант для быстрого устройства на работу. А сферы Machine Learning и Data Science хороши в долгосрочной перспективе.

Статья написана Python Academy

Универсальная подборка ресурсов для изучения Python с нуля. Начать с книги, YouTube или онлайн-курса – выбор ваш. Самое важное – начать с чего-то.

Книги для изучения

«Изучаем Python» от Марка Лутца – это учебник, написанный понятным языком для программистов с разным уровнем подготовки.

«Глубокое обучение на Python» от Франсуа Шолле – столь сложную тему, как глубокое обучение, лучше изучать с помощью этой книги Python.

«Изучаем Python. Программирование игр и веб-приложения» от Эрика Мэтиза – из этой книги вы узнаете, как создавать игры, визуализировать данные и научитесь создавать веб-приложения на Django.

Youtube каналы

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

Олег Молчанов – самое качественное, что есть на русскоязычном YouTube про Python. На канале есть плейлисты по Django, Flask, асинхронности, веб-парсингу и многому другому.

Moscow Python – записи конференций и митапов про более продвинутые темы. Сообщество активно сотрудничает с такими компаниями, как Mail.Ru Group, Rambler, Яндекс и другими.

Бесплатные курсы

Математика и Python для анализа данных – совместный курс от МФТИ и Яндекс на Coursera для изучения языка. Вы также получите знания для анализа данных.

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

Code Academy –бесплатный учебный ресурс для изучения программирования. На этой платформе вы найдете уроки по самым разным языкам, не только по Python.

Сайты для практики

Codewars – задачи по написанию кода организованы по типу боевых искусств, каждая задача называется ката.

LeetCode – подготовка к техническим интервью является основным направлением этого ресурса.

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

Другое

Python World – cамоучитель по Python. Отлично подходит для изучения конкретных тем в программировании.

Real Python – премиальный онлайн-курс. На сайте есть много отличных статей, которые можно читать совершенно бесплатно.

Статья подготовлена образовательной организацией Python Academy.

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

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

Что такое градиент

Начнем с самых базовых понятий о производных. По сути производная есть тангенс угла наклона касательной (да, она как бы касается графика) к графику в точке, в которой вы ее вычисляете. А поскольку производная в точках минимума (и максимума тоже) всегда обращается в нуль (касательная просто становится параллельна оси ОХ), этот принципе часто используют в задачах оптимизации, или поиска минимального значения. На картинке ниже приведен очень простой пример графика, назовем его графиком функции потерь (или loss function, не будем подробно останавливаться на этом сейчас, это не столь важно). Здесь функция f(x) имеет минимум в точке x = 0, а касательные, построенные в точках x0 = 0, 0.4, 0.6, указывают направление, в котором стоит двигаться, если нужно отыскать минимум (ну или просто наклон функции, чем он меньше, тем мы ближе к локальному минимуму! Как мы видим, касательная функции в точке x = 0 проходит точно параллельно оси ОХ, что и подтверждает нашу первоначальную гипотезу о минимуме в этой точке.

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

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

Кстати, градиент какой-либо функции f в математике обычно обозначают таким забавным значком перевернутого треугольника – ∇f.

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

Но основная идея останется та же самая – для того, чтобы отыскать минимум, нужно двигаться в сторону наискорейшего убывания функции (там где наклон становится очень маленьким), а значит, нужно уметь работать с градиентом.

Что такое градиентный спуск

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

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

Как же все таки это работает? Известно, что градиент является направлением наискорейшего роста функции, а градиент со знаком минус (назовем его "антиградиент") – направлением наискорейшего убывания. Это ключевое свойство градиента, обосновывающее его использование в методах оптимизации.

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

Давайте запишем это более формально. Тогда градиентный спуск состоит в повторении следующих шагов. Не волнуйтесь, далее мы разберем их в коде на Python.

Суть каждого такого алгоритма – процесс получения наименьшего значения ошибки.

Перейдем к практике

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

Для интереса возьмем функцию

с производной

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

Теперь выберем начальную точку x0 = 6 (начальная точка может быть практически любой, за исключением концов отрезка, если мы рассматриваем функцию на некотором отрезке).

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

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

Мы выберем gamma = 0.01.

Попробуйте поиграть с этими двумя параметрами.

Теперь попробуем реализовать все что мы запланировали в функции get_minumum.

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

Запишем производную df в виде лямбда функции (удобный концепт, позволяющий избавиться от тела функции), и передадим ее в функцию get_minimum вместе с начальным значением x0 и шагом gamma.

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

Статья подготовлена образовательной организацией Python Academy

На сегодняшний день, пакет Pandas – самый важный инструмент во всем, что касается анализа данных. Многие аналитики и data scientist'ы пользуются этим пакетом.

Если вы думаете о карьере в области data science, то крайне важно, чтобы вы сначала изучили Pandas. В этой статье мы рассмотрим наиболее важную информацию о Pandas, в том числе о том, как его установить и как его использовать.

Для чего нужен Pandas

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

Например, скажем, вы хотите исследовать набор данных, хранящийся в формате CSV на вашем компьютере. Pandas может извлекать данные из CSV в DataFrame – собственный специальный формат данных – и затем позволит вам делать такие вещи, как:

• Рассчитать статистику и ответить на вопросы о данных, например:
  1. Каково среднее значение, медиана, максимум или минимум каждого столбца?
  2. Коррелирует ли столбец A со столбцом B?
  3. Как выглядит распределение данных в столбце C?
• Очистить данные, выполнив такие действия, как удаление пропущенных значений и фильтрацию строк и/или столбцов по некоторым критериям
• Визуализировать данные с помощью Matplotlib. Графики, диаграммы, гистограммы и многое другое
• Сохранить очищенные, преобразованные данные обратно в CSV, другой файл или базу данных

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

Первые шаги в Pandas

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

Для импортирования пандас обычно используется короткое имя – pd.

Теперь перейдем к базовым компонентам этого пакета.

Ключевые компоненты: Series и DataFrames

Основные компоненты пандас – Series и DataFrame. Series – что-то вроде столбца с данными, DataFrame – это таблица, созданная из столбцов Series.

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

Теперь создадим DataFrame, в котором содержатся заказы на яблоки и апельсины.

А теперь поглядим что получилось:

Как это работает?

Каждый элемент (ключ, значение) в данных соответствует столбцу в результирующем DataFrame. Индекс в DataFrame пандас создал автоматически в виде чисел 0-3, но мы также можем создать и собственный индекс, в момент инициализации DataFrame.

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

Вот что получилось:

Теперь можно запросто найти заказ клиента, используя его имя и функцию loc.

Получаем ожидаемый результат:

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

Чтение данных

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

Чтение данных из CSV

Всё, что нам нужно для работы с CSV-файлами, так это одна строка для загрузки данных.

А вот что получилось:

CSV файлы по умолчанию не имеют индексов, поэтому все что нам нужно сделать, это указать столбец с индексами при помощи index_col.

Теперь индексация работает как надо.

Чтение данных из JSON

Если у вас есть JSON-файл (который по сути является словарем), пандас может прочитать его так же легко.

Тот же самый результат:

Обратите внимание, что на этот раз индекс пришел правильно, поскольку мы использовали JSON. Не стесняйтесь открывать файл с данными data.json в блокноте, чтобы видеть как именно он работает.

Pandas попытается выяснить, как создать DataFrame, проанализировав структуру вашего JSON, и иногда это приводит к неправильным результатам. Часто вам будет нужно установить аргумент orient в зависимости от структуры, поэтому обязательно посмотрите документацию read_json об этом аргументе, чтобы узнать, какую ориентацию вы используете.

Наиболее важные операции с DataFrame

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

Для начала работы мы воспользуемся датасетом IMDB. Загрузим этот набор данных из CSV и определим столбец с названиями фильмов в качестве индекса.

Просмотр данных

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

По умолчанию команда .head() выводит первые 5 строчек, но в аргументах функции можно указать, например, вывести первые 10 строчек – .head(10).

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

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

Получение информации о данных

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

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

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

Как работать с пропущенными значениями

При изучении данных вы, скорее всего, столкнетесь с отсутствующими или нулевыми значениями, которые по сути являются своего рода "заполнителями" для несуществующих значений. Чаще всего это None или np.nan, каждый из которых обрабатывается по-разному в разных ситуациях.

Есть два варианта работы с нулями:

1. Избавиться от строк или столбцов с нулями;
2. Заменить нули ненулевыми значениями.

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

Обратите внимание, что isnull() возвращает DataFrame, где каждая ячейка имеет значение True или False в зависимости от состояния этой ячейки.

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

.isnull() сам по себе не настолько полезен, как его сочетание с другими методами, например с sum().

Теперь мы четко видим, что в revenue_millions отсутствует 128 значений, и 64 – в metascore.

Удаление нулевых значений

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

Удалить нули довольно просто.

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

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

Замена данных

Замена данных (imputation) – это традиционный метод feature engineering, используемый для работы с данными в которых присутствуют нулевые значения.

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

Давайте посмотрим на замену пропущенных значений в столбце revenue_millions.

Сначала извлечем этот столбец в его собственную переменную.

Использование квадратных скобок – это основной способ выбора столбцов в DataFrame, как если бы нужно было обратиться к значению в словаре dict в Python.

revenue теперь содержит Series, а не DataFrame.

Далее мы заменим нулевые значения в revenue используя средние значения mean по столбцу.

А теперь остается только заменить нулевые значения на средние с помощью функции fillna().

Теперь все нулевые значения заменены на среднее значение этого столбца. Обратите внимание, что при использовании inplace=True фактически был переписан исходный датафрейм movies_df.

Конечный результат получится примерно следующий:

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

Исследование, очистка, преобразование и визуализация данных с помощью Pandas в Python – это важный навык в Data Science. А чистая обработка данных – это целых 80% работы в качестве Data Scientist'а. Поэтому так важно знать основы работы с данными в Pandas.

Статья подготовлена образовательной организацией Python Academy

Асинхронность уже не является просто модным словечком в сообществе Python. После выпуска библиотеки asyncio в версии 3.5, разработчики Python признали влияние Node.js в сфере веб-разработки и ввели в язык два новых ключевых слова – async и await. Это был крайне важный момент, потому что разработчики максимально осторожно относятся к расширению основного синтаксиса, если только нет острой необходимости, что только указывает на то, насколько принципиально необходимыми считались асинхронные возможности.

В результате перед асинхронностью открылись новые границы: новые и старые библиотеки начали использовать функционал корутин, асинхронные фреймворки взорвались популярностью, а на сегодняшний день пишут всё больше и больше новых модулей. Производительность наравне (или даже лучше) c Node.js уже не является чем-то необычным. И нет никаких причин, из-за которых вы не могли бы делать тысячи запросов в секунду, если ваш код не создаёт высокие нагрузки на процессор.

Пожалуй, хватит мотивации. Давайте лучше глянем на текущую ситуацию в Python и рассмотрим некоторые из лучших асинхронных фреймворков.

Tornado

На удивление, Tornado – достаточно старый фреймворк. Самый первый релиз был выпущен ещё в далёком 2009 году (более десяти лет назад), и сейчас его основное внимание направлено на обеспечении надежного асинхронного программирования с высоким параллелизмом.

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

• Корутины и другие примитивы (tornado.gen, tornado.locks, tornado.queues и т. д.)
• Сетевые модули (tornado.ioloop, tornado.iostream и т. д.)
• Асинхронные сервера и клиенты (tornado.httpserver, tornado.httpclient и т. д.)

Они были совмещены для получения финальный модулей фреймворка: tornado.web, tornado.routing, tornado.template и тому подобные.

Tornado имеет сильную и преданную поддержку в сообществе Python и используется опытными архитекторами для создания высокоэффективных систем. Это фреймворк, который уже давно имеет ответ на проблемы параллелизма, но не стал мейнстримом, поскольку он не поддерживает стандарт WSGI. А также важно помнить, что основная часть библиотек Python всё ещё синхронна.

Sanic

Sanic – это "современный" фреймворк в прямом смысле слова: он не работает в Python ниже версии 3.6, поддерживает синтаксис async/await из коробки, и как следствие, это не заставляет вас читать кучу документации и держать в голове все крайние случаи, прежде чем вы сможете написать свой первый обработчик.

В результате получившийся синтаксис довольно приятен; он напоминает код, который вы написали бы на любом другом микрофреймворке (например, Flask, CherryPy) просто с несколькими асинхронными вставками:

Sanic, пожалуй, является самым популярным и наиболе понравившемся сообществу асинхронным фреймворков в мире Python. Он имеет практически весь функционал, который вам понадобился бы для проекта – маршрутизация, middleware, куки, контроль версий, блупринты, представления на основе классов, статические файлы, streaming, сокеты и многое другое. А то, что он не предоставляет из коробки – шаблоны, поддержка баз данных, I/O операции с файлами, очереди – вы можете добавить сами, так как существует уже достаточно асинхронных библиотек для всего, что душа пожелает.

Vibora

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

Как вы можете видеть, Vibora заявляет, что она в несколько раз быстрее классических фреймворков и более чем в два раза быстрее Sanic, своего ближайшего конкурента. Конечно, бенчмарки не всегда могут быть объективными показателями. 🙂

Хотя по синтаксису и функциям Vibora сравнима с Sanic (или, возможно, даже немного лучше, поскольку она объединяет популярные библиотеки и такие вещи, как шаблоны, доступные из коробки), я бы счел Sanic более зрелым, поскольку он существует дольше и имеет более обширное сообщество.

Но если вы помешаны на производительности, то Vibora может дать вам большие возможности. Тем не менее, на момент написания статьи Vibora кардинально переписывается, чтобы стать ещё быстрее, и ссылка на страницу про производительность говорит нам о том, что фреймворк находится под “тяжелой разработкой". Однако не спешите выбирать Vibora для своих проектов, иначе вы рано или поздно столкнётесь с критическими изменениями. Но всё-таки это только начало асинхронного мира Python, и не следует ожидать чего-либо железно стабильного.

Quart

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

Quart соответствует стандарту ASGI, который является преемником знаменитого стандарта WSGI и предлагает асинхронную поддержку. Самое интересное в Quart то, что он не только похож на Flask, но и фактически совместим с Flask API! Автор этого фреймворка хотел сохранить ощущение работы с Flask и просто добавить к нему поддержку асинхронности, WebSockets и HTTP 2. В результате вы можете изучить Quart прямо по документации Flask'а, просто имея в виду, что функции в Quart являются асинхронными.

Выглядит (почти) как Flask, разве не так?

Поскольку Quart – это эволюция Flask, то и весь функционал из Flask также доступен: маршрутизация, middleware, сессии, шаблоны, блупринты и так далее. Более того, вы даже можете использовать расширения Flask непосредственно внутри Quart. Загвоздка заключается лишь в том, что поддерживается Python только версии 3.7+, но если вы не используете последнюю версию Python, то и использовать асинхронность имеет мало смысла. 🙂

Документация действительно нужна, если у вас нет предварительного опыта работы с Flask, но я могу всё-таки рекомендовать Quart, поскольку это, вероятно, единственный асинхронный фреймворк, который скоро выйдет в версии 1.0.

FastAPI

Последним (но самым впечатляющим) фреймворком в этом списке является FastAPI. Нет, это не только API-фреймворк; на самом деле FastAPI, похоже, является самым многофункциональным и богатым документацией фреймворком, с которым я столкнулся при исследовании асинхронных фреймворков в Python.

Интересно, что автор фреймворка глубоко изучил несколько других фреймворков, от классических, таких как Django, до более современных, таких как Sanic, а также изучил различные технологии в NestJS (веб-фреймворк Node.js, Typescript). Про их философию развития и масштабные сравнения можно прочитать здесь.

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

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

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

Фреймворк также создаёт автоматическую документацию для моделей в JSON формате.

Современное развитие: да, слово "современный" часто бросается в глаза, но именно в контексте FastAPI оно уместно. Внедрение зависимостей и аннотация типов – это объекты первого класса, не только позволяющие применять хорошие принципы программирования, но и предотвращающие ошибки и путаницу в долгосрочной перспективе.

Обширная документация: не знаю насчёт вас, но я большой любитель хорошей документации. И в этой области FastAPI преуспел лучше других. В нем есть страницы за страницами документации, объясняющие почти каждую тонкость и моменты, в которых нужно быть осторожным, для разработчиков всех уровней. Сразу видно, что в такую документацию вложили сердце и душу. И единственное сравнение, которое можно найти, – это документация Django (да, документация FastAPI настолько хороша).

Помимо всего прочего: FastAPI поддерживает WebSockets, Streaming, а также GraphQL, помимо того, что у него есть все традиционные функции, такие как CORS, сессии, куки и многие другие.

А как насчет производительности? FastAPI построен на удивительной библиотеке Starlette, в результате чего производительность сравнима — с Node.js, а в некоторых случаях даже Go! В целом, у меня сложилось стойкое предчуствие, что FastAPI будет мчаться вперёд как лучший асинхронный фреймворк для Python.

Заключение

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

Но все сказано и сделано; Python готов к продакшну и может обеспечить хорошую производительность, когда речь заходит о веб-фреймворках. Если вы долго думали о переходе на Node.js, то теперь вам этого не требуется! 🙂

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

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

Основа программы

Для начала импортируем все нужные модули и создадим окно приложения с определенными размерами.

Дальше сделаем надпись, призывающую ввести пароль. Расположим ее по центру по горизонтали и немного сместим вверх.

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

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

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

Сейчас уже можно написать root.mainloop() и посмотреть на промежуточный результат.

Часть вируса

Итак, какое-то приложение уже готово, осталось кое-что добавить и превратить его в вирус.

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

Сделаем окно полноэкранным, написав следующее, а также уберем курсор мыши.

Внимание! Чтобы выйти из такого приложения на данном этапе, нужно нажать комбинацию Alt+F4.

Далее напишем цикл, в котором будет проверка ввода и обновление экрана.

Думаю, что здесь всё понятно, при вводе '1234' программа прекратит своё выполнение при помощи sys.exit()

Примерно такая картина получается на данный момент.

Последние штрихи

Всё вроде бы хорошо, но всё еще есть несколько проблем: окно без проблем закрывается с помощью Alt+F4, курсор можно переместить на соседний монитор (если их 2+), есть возможность переключаться между программами (Alt+Tab) и там спокойно что-то делать. Сейчас мы всё это решим.

Для предотвращения закрытия окна комбинацией Alt+F4, достаточно написать одну строчку перед циклом.

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

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

То есть курсор всегда будет перемещать в координаты (0, 0) – левый верхний угол.

На всякий случай перед циклом надо написать еще вот это.

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

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

Исходный код – https://pastebin.com/2uDCyFT9

Статья подготовлена образовательной организацией Python Academy

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

Освещение

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

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

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

Зрение

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

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

• Моргайте чаще, это не даст глазам пересыхать.
• Делайте перерывы, чтобы глаза смогли отдохнуть.
• Исключите блики на своем мониторе - наклейте на экран матовую или антибликовую пленку или раздобудьте безбликовый монитор, если таковой еще не имеется.
• Следите, чтобы разница между яркостью окружения и монитора была не слишком большой. Также советую установить f.lux, это приложение автоматически изменяет яркость экрана и температуру цвета в течение дня в зависимости от вашей геолокации.
• И самый легкий совет: монитор должен находиться на расстоянии 0.5–1 м от глаз – это примерно длина вытянутой руки.

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

1. Для улучшения циркуляции глазной жидкости аккуратно помассируйте подушками указательных и средних пальцев роговицу глаза. Повторить 6-8 раз.
2. Сфокусируйте свой взгляд на несколько секунд сначала на ближнем предмете, а затем на дальнем. Рекомендуется сделать 10 подходов. Упражнение отлично подойдет для поддержания хрусталика глаза в тонусе и снизит риск близорукости.
3. Водите глазами в разные стороны – снизу вверх и слева направо. Можно выполнить и круговые движения. Повторить не менее 10 раз. Так мы укрепляем глазодвигательные мышцы.

Сидение

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

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

Спина и шея

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

Далее перейдем к упражнениям для спины и шеи:

1. Положите сплетенные пальцы рук на затылок, удерживая голову, попробуйте наклонить ее назад.
2. Проделайте тоже самое, удерживая руки на лбу.
3. Сядьте на стул. Прикоснитесь ладонями к спинке стула, слегка поворачивая корпус.
4. Сядьте на стул и максимально прижимайтесь к спинке лопатками и крестцом. Выполняйте упражнение плавно, вы не должны чувствовать боль.
5. Встаньте на четвереньки, выгните спину, слегка отклоняя её в стороны.

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

Запястья

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

Также привожу пример упражнений, которые лучше делать каждый день:

1. Сожмите и разожмите кулаки несколько раз.
2. Сожмите кулак и сгибайте всю кисть несколько раз вверх-вниз.
3. Сожмите кулак (не очень крепко) и повращайте кистями в разные стороны.
4. Сложите пальцы в ровный ряд, отведите большой в сторону и повращайте им.

Питание

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

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

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

Сон

Стоит добавить важность правильного сна. Даже небольшое недосыпание (сон 6-7 часов), циркадный сдвиг (изменение времени ухода ко сну на 1-2 часа за одну ночь) или уменьшение фаз глубокого или быстрого сна уменьшают качество умственных способностей следующим образом:

• Ухудшение контроля над эмоциями, уменьшение устойчивости к стрессам, силы воли и способности фокусироваться.
• Гормональное нарушение. Меньше энергии и хуже настроение.
• Существенное снижение иммунитета.
• Существенное ухудшение способности к запоминанию.
• Значительное ухудшение способности видеть нетривиальные решения.

Несколько советов для лучшего сна:

1. Выберите время отхода ко сну так, чтобы провести в кровати 8.5-9 часов, и не сдвигайте его больше, чем на 20 минут в день.
2. Ограничьте для себя спектр синего света за 3-4 часа до сна. Используйте фильтры синего цвета для всех экранов.
3. Не употребляйте алкоголь.

Статья подготовлена образовательной организацией Python Academy

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

Немного истории

Модуль multiprocessing изначально был добавлен в Python 2.6. Этот модуль позволяет создавать процессы таким же образом, как при создании потоков при помощи модуля threading.

Суть в том, что, в связи с тем, что теперь мы создаем процессы, появляется возможность обойти GIL (Global Interpreter Lock) и воспользоваться возможностью использования нескольких процессоров (или даже ядер) на компьютере.

Пакет multiprocessing также включает ряд API, которых вообще нет в модуле threading. Например, там есть очень удобный класс Pool, который можно использовать для параллельного выполнения функции между несколькими входами. Мы рассмотрим Pool немного позже. А начнем пожалуй с класса Process модуля multiprocessing.

Приступим к работе с Multiprocessing

Класс Process очень похож на класс Thread модуля threading. Давайте попробуем создать несколько процессов, которые вызывают одну и ту же функцию, и посмотрим, как это сработает.

Начнем с того, что создадим функцию func. Внутри func возводим переданное число number в квадрат. Мы также используем модуль os для того, чтобы получить id текущего процесса. С помощью него можно определить какой именно процесс вызывает функцию.

import os
from multiprocessing import Process


def func(number):
    proc = os.getpid()
    print(f'{number} squared to {number ** 2} by process id: {proc}')

Теперь наконец создадим функцию, для создания 5 процессов для 5 целых чисел, и посмотрим что получилось.

def main():
    procs = []
    numbers = [1, 2, 3, 4, 5]

    for number in numbers:
        proc = Process(target=func, args=(number,))
        procs.append(proc)
        proc.start()

    for proc in procs:
        proc.join()

Здесь хотелось бы обсудить несколько важных моментов. Во-первых, f-строки работают только в версиях Python 3.6 или выше. Во-вторых, аргументы в функции Processэто всегда кортеж, даже если там всего один элемент.

В функции main, в нижнем блоке кода, мы создаем несколько процессов и стартуем их с помощью функции start().

Самый последний цикл только вызывает метод join()для каждого из процессов, что говорит Python подождать, пока процесс завершится. Если вам нужно остановить процесс, вы можете вызвать метод terminate().

Запускаем полученный скрипт.

if __name__ == '__main__':
    main()

Вывод будет примерно таким.

1 squared to 1 by process id: 1600
2 squared to 4 by process id: 1601
3 squared to 9 by process id: 1602
4 squared to 16 by process id: 1603
5 squared to 25 by process id: 1604

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

from multiprocessing import Process, current_process


def func(number):
    proc = current_process().name
    print(f'{number} squared to {number ** 2} by process {proc}')

def main():
    procs = []
    numbers = [1, 2, 3, 4, 5]

    for number in numbers:
        proc = Process(target=func, args=(number,))
        procs.append(proc)
        proc.start()

    for proc in procs:
        proc.join()


if __name__ == '__main__':
    main()

Вывод будет таким.

1 squared to 1 by process Process-1
2 squared to 4 by process Process-2
3 squared to 9 by process Process-3
4 squared to 16 by process Process-4
5 squared to 25 by process Process-5

Кроме того, есть возможность напрямую назначить имя процессу.

proc = Process(target=func, name='My Process', args=(number,))

Класс Pool

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

from multiprocessing import Pool


def func(number):
    return number ** 2
    
def main():
    numbers = [1, 2, 3]
    with Pool(processes=3) as pool:
        print(pool.map(func, numbers))
        
        
if __name__ == '__main__':
    main()

Здесь я создал экземпляр Pool с помощью контекстного менеджера with...as... и указал ему создать три рабочих процесса. Далее я использовал метод map для отображения функции для каждого процесса. Наконец вывожу результат, который в данном случае является списком [1, 4, 9].

Реальный пример

Попробуем применить метод requests.get()к некоторому списку сайтов. Последовательное выполнение задачи отнимет много времени, но что если сделать это параллельно?

import requests
from multiprocessing import Pool


def main(processes):
    urls = [
        'http://www.python.org',
        'http://www.python.org/about/',
        'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
        'http://www.python.org/doc/',
        'http://www.python.org/download/',
        'http://www.python.org/getit/',
        'http://www.python.org/community/',
        'https://wiki.python.org/moin/',
        'http://planet.python.org/',
        'https://wiki.python.org/moin/LocalUserGroups',
        'http://www.python.org/psf/',
        'http://docs.python.org/devguide/',
        'http://www.python.org/community/awards/'
    ]
    
    # создадим пул работников
    with Pool(processes=processes) as pool:
        # получим результат с помощью функции map
        results = pool.map(requests.get, urls)

Теперь сравним скорости обработки при различном размере пула.

if __name__ == '__main__':
    # -- 13 Pool -- #
    main(processes=13)

    # -- 8 Pool -- #
    main(processes=8)

    # -- 4 Pool -- #
    main(processes=4)

    # -- Single -- #
    main(processes=1)

Вообще говоря, скорость выполнения таких процессов сильно зависит от скорости и качества интернет соединения. Кроме того, логически более правильно здесь было бы использовать async, а не multiprocessing. Однако даже в таком примере виде прирост скорости.

На моей машине получилось вот так:

13 Pool: 2.6185 sec
8 Pool: 2.7000 sec
4 Pool: 3.0071 sec
Single: 7.3520 sec

Итог

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

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

Статья подготовлена образовательной организацией Python Academy

Хочешь писать более лаконичный и читаемый код а также умещать как можно больше смысла в одно выражение? Считаешь, что лучше один раз прочитать об уловках Python, чем провести остаток своих дней за чтением ненужной документации?

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

1. Правдивость различных объектов

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

Кроме того, разумеется, 0 – тоже False, а остальные числа – True.

Например, следующие выражения эквивалентны:

string = 'Test' # True пример
# string = ''   # False пример

if len(string) > 0:
    print('Объект string не пуст')

if len(string):  # Здесь 0 преобразовывается к False
    print('Объект string не пуст')

if string != '':
    print('Объект string не пуст')

if string: # Здесь пустая строка преобразовывается к False
    print('Объект string не пуст')

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

Наиболее элегантным и соответствующим "pythonic" стилю вариантом будет именно if string: ...

2. Проверка на вхождение подстроки

Это маленькая, довольно очевидная подсказка, но даже я узнал о ней не сразу. Должно быть очевидно, что можно проверить, содержится ли нужный элемент в кортеже, списке, словаре, с помощью конструкции if item in list: .... Но это может сработать и для строк!

Можно конечно написать и так:

string = 'Hi there' # True пример
# string = 'Hello' # False пример
if string.find('Hi') != -1:
    print('Success!')

Но гораздо понятнее и красивее будет так:

string = 'Hi there' # True example
# string = 'Hello' # False example
if 'Hi' in string:
    print('Success!')

3. Лямбда-функции

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

Следующие два определения полностью идентичны:

def add(a,b):
    return a + b

add = lambda a, b: a + b

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

squares = map(lambda x: x * x, [1, 2, 3, 4, 5])

# squares = [1, 4, 9, 16, 25]

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

4. Списковые включения

Возможно где-то до этого ты уже мог слышать понятие «list comprehensions». Это такой способ уместить цикл for, блок if и присваивание в одну строку.

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

Если ты совсем недавно начал писать на Python, то скорее всего напишешь так:

numbers = [1, 2, 3, 4, 5]
squares = []
for number in numbers:
    squares.append(number * number)

# squares = [1, 4, 9, 16, 25]

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

numbers = [1, 2, 3, 4, 5]
squares = map(lambda x: x * x, numbers)

# squares = [1, 4, 9, 16, 25]

Да, определенно этот код короче предыдущего, но всё еще некрасив. С первого взгляда сложно сказать, что делает функция map (она принимает в качестве аргументов функцию и список и применяет функцию к каждому элементу списка). К тому же мы вынуждены определять функцию, это выглядит довольно беспорядочно.

Но, оказывается, можно писать проще и понятнее:

numbers = [1, 2, 3, 4, 5]
squares = [number * number for number in numbers]

# squares = [1, 4, 9, 16, 25]

Вторая строчка здесь читается практически как исполняемый псевдокод. Чем это хорошо? Даже без знаний Python человек без проблем определит что делает этот код.

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

А что, если нас интересует фильтрация списка? Например, требуется удалить все четные элементы.

Новичок в программировании на Python напишет так:

numbers = [1, 2, 3, 4, 5]
odds = []
for number in numbers:
    if number % 2:
        odds.append(number)

# odds = [1, 3, 5]

Очень просто, не так ли? Но код занимает 5 строк, содержит два уровня отступов и при этом делает совершенно тривиальную вещь.

Можно уменьшить размер кода с помощью функции filter:

numbers = [1, 2, 3, 4, 5]
odds = filter(lambda x: x % 2, numbers)

# odds = [1, 3, 5]

Аналогично функции map, о которой мы говорили выше, filter сокращает код, но выглядит довольно уродливо.

Как работает функция filter? Как и map, filter получает функцию и список. Если функция от элемента возвращает True, элемент включается в результирующий список.

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

numbers = [1, 2, 3, 4, 5]
odds = [number for number in numbers if number % 2]

# odds = [1,3,5]

6. Одновременное использование map и filter

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

Неопытный программист на Python напишет так:

numbers = [1, 2, 3, 4, 5]
odd_squares = []
for number in numbers:
    if number % 4:
        odd_squares.append(number * number)

# odd_squares = [1, 9, 25]

Увы, код начал растягиваться вправо. Может, получится упростить его?

Попробуем использовать map и filter:

numbers = [1, 2, 3, 4, 5]
odd_squares = map(lambda x: x * x, filter(lambda x: x % 2, numbers))

# odd_squares = [1, 9, 25]

Раньше map и filter было трудно читать, а теперь вообще невозможно. Очевидно, это не лучшая идея.

Попробуем спасти ситуацию с помощью генератора списков:

numbers = [1, 2, 3, 4, 5]
odd_squares = [number * number for number in numbers if number % 2]
# odd_squares = [1, 9, 25]

Да, получилось немного длиннее, чем предыдущие примеры со списковым включением, но, мне кажется, вполне читабельно. Определенно лучше, чем цикл for.

Кстати, генератор списков сначала фильтрует, а затем уже отображает. Если нужно наоборот, получится сложнее. Придется использовать либо вложенные генерации, либо map и filter, либо обычный цикл for, в зависимости от того, что проще.

7. Моржовый оператор

Новый способ присваивания выражения (:=), или оператор «морж», был самой обсуждаемой функцией, представленной в последней версии Python. Новое дополнение к языку было предложено в PEP 572.

Сразу посмотрим, как это выглядит в коде:

(x:= 5)
print(x)
# Output: 5

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

Пойдем дальше и рассмотрим пример, в котором раскрывается весь потенциал моржового оператора:

# пусть a – контейнер или последовательность
if (n:= len(a)) > 10:
    print(f'Слишком много элементов, а именно {n}')

То есть мы только что прямо в проверке условия объявили новую переменную n и далее использовали ее вместо того, чтобы вычислять значение заново. Для сравнения посмотрим, как мы это могли сделать раньше:

n = len(a)
if n > 10:
    print(f'Слишком много элементов, а именно {n}')

# или

if len(a) > 10:
    print(f'Слишком много элементов, а именно {len(a)}')

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

Ну и еще пара примеров на закуску:

• Повторно используем значение в списке:

foo = [y:= f(x), y * 2, y * 3]

# вместо

foo = [f(x), f(x) * 2, f(x) * 3]

• Повторное использование значения из условия в генераторных выражениях:

[y for x in data if (y:=f(x))]

# вместо

result = []
for x in data:
    result = f(x)
    if result:
        results.append(result)

• Чтение данных из файла внутри циклов while:

while (block := f.read(256)) != '':
    process(block)

# вместо

while True:
    stuff()
    if fail_condition:
        break

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

Статья подготовлена образовательной организацией Python Academy

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

Подготавливаем инструменты

Сперва давай зарегистрируем тебя на GitHub. Необходимо создать аккаунт (рано или поздно он точно может пригодиться) и установить Git. После создания аккаунта жмем "New repository". Называем его TimeChanger, можем добавить какое-либо описание, и жмем "Create repository".

Теперь установим Git. На Linux это можно сделать с помощью следующей команды:

$ sudo apt-get install git-all

На MacOS и Windows его нужно будет скачать и установить.

Ссылка для скачивания на MacOS

Ссылка для скачивания на Windows

Скачиваем Git по ссылкам выше и устанавливаем, это несложно.

Да, и не забудь конечно же зарегистрироваться на Heroku.

Командная строка

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

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

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

Виртуальные среды

Мы будем работать с виртуальной средой virtualenv. Сначала установим ее, выполнив команду в терминале Windows:

$ pip install virtualenv

Для MacOS или Linux будем использовать:

$ pip3 install virtualenv

Теперь давай наведем порядок в файлах. Создай новую папку и перейди в неё в терминале или командной строке. Нам нужно инициализировать в ней virtualenv:

$ virtualenv my_env

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

Переходим в папку my_env. Здесь, в принципе и на Windows и на Linux/MacOS синтаксис одинаковый, используем команду cd. Теперь нужно клонировать git-репозиторий.

Вводим следующую команду:

$ git clone https://github.com/adreex/TimeChanger

Таким образом мы скопировали в папку проект отсюда: https://github.com/adreex/TimeChanger

В той же папке my_env запустим virtualenv:

• На Windows: $ scripts\\activate.bat
• На Linux/MacOS: $ source bin/activate

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

Установка зависимостей

Вообще говоря, в скопированном нами репозитории уже есть файл requirements.txt. Но далее нам понадобится рабочий интерпретатор на нашей локальной машине, для создания файла сессии. И кроме того, вдруг когда-нибудь понадобится деплоить собственный код?

Из терминала переходим в папку репозитория (мы клонировали ее под именем TimeChanger), и устанавливаем все необходимые зависимости:

$ pip install Pillow==6.0.0 pyaes==1.6.1 pyasn1==0.4.5 pytz==2019.1 rsa==4.0 Telethon==1.8.0

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

Теперь нужно создать список зависимостей Heroku. Это несложно:

$ pip freeze > requirements.txt

Финальные шаги

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

Содержимое файла должно быть таким:

worker: python main.py

Добавим файл __init__.py в папку с проектом. Он может быть пустым (просто оставь там закомменченную строку вида # test), но он должен там быть.

Добавим все файлы проекта и сделаем коммит в репозиторий:

$ git init
$ git add .
$ git commit -m 'initial commit'
$ git push --set-upstream <https://github.com/имя_вашего_профиля/TimeChanger> master

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

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

Для установки на Linux достаточно ввести команду:

sudo snap install heroku --classic

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

python3 main.py

После этого вводим телефон, и создаем новую сессию в Telegram. Нам понадобится файл session.session, который мы зальем (вместе с остальным кодом) с помощью Git на Heroku

$ git add .
$ git commit -m 'initial commit'

Логинимся в Heroku, создаем приложение, и делаем пуш кода:

$ heroku login
$ heroku create
$ git push heroku master
$ heroku ps:scale worker=1

С этого момента приложение должно работать на сервере Heroku. Если что-то пойдёт не так, проверить логи можно следующим образом:

$ heroku logs --tail

Коды ошибок можно найти на сайте Heroku.

Итог

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

Материал подготовлен образовательной организацией Python Academy.