Если вы разработчик, архитектор или просто любите порядок — пора познакомиться с BPMN. Это не аббревиатура очередного круизного лайнера, а Business Process Model and Notation — нотация для моделирования бизнес-процессов. Грубо говоря, это способ рисовать понятные схемы с задачами, условиями, событиями и участниками, чтобы визуализировать, как работает система. И знаете что? Создавать такие диаграммы можно прямо из Python.
Давайте разберемся, как программно строить BPMN-диаграммы. На помощь приходит библиотека bpmn-python. Она позволяет описывать процесс на языке Python и экспортировать его в формат BPMN 2.0 — достаточно, чтобы открыть в любом визуальном редакторе, например, Camunda Modeler или bpmn.io.
Устанавливаем:
Теперь — минимальный пример, как это выглядит:
Что происходит: мы создаём процесс "Order Process", добавляем стартовое событие, задачу, условный шлюз (эксклюзивный gateway) и завершающее событие. Затем соединяем элементы стрелками. В итоге получаем изображение диаграммы — понятно и без слов.
BPMN хорош тем, что легко читается — даже менеджер без технического фона поймёт, что происходит в вашем процессе. Кроме того, такая визуализация помогает выявить узкие места и лишнюю логику ещё на этапе проектирования.
Если хочется усложнить сценарий — добавьте участника (пул или дорожку), события сообщений, циклические задачи и параллельные шлюзы. Всё это поддерживается в bpmn-python, хоть и не всегда очевидно — документация скромная. Тем не менее, для генерации базовых бизнес-процессов инструмента достаточно.
В мире, где почти каждый API, микросервис и скрипт становится частью сложного потока, визуализация таких процессов ценится на вес золота. А когда эту визуализацию можно собрать автоматически из Python — это становится частью DevOps-магии.
Давайте разберемся, как программно строить BPMN-диаграммы. На помощь приходит библиотека bpmn-python. Она позволяет описывать процесс на языке Python и экспортировать его в формат BPMN 2.0 — достаточно, чтобы открыть в любом визуальном редакторе, например, Camunda Modeler или bpmn.io.
Устанавливаем:
pip install bpmn-python
Теперь — минимальный пример, как это выглядит:
from bpmn_python.bpmn_diagram_rep import BpmnDiagramGraph
from bpmn_python.bpmn_diagram_drawer import BpmnDiagramDrawer
diagram = BpmnDiagramGraph()
process_id = diagram.create_new_process_diagram_graph(diagram_name='Order Process')
start_event_id = diagram.add_start_event_to_diagram(process_id, 'StartOrder')
task_id = diagram.add_task_to_diagram(process_id, 'ReceiveOrder')
gateway_id = diagram.add_exclusive_gateway_to_diagram(process_id, 'CheckStock')
end_event_id = diagram.add_end_event_to_diagram(process_id, 'EndProcess')
diagram.add_sequence_flow_to_diagram(process_id, start_event_id, task_id)
diagram.add_sequence_flow_to_diagram(process_id, task_id, gateway_id)
diagram.add_sequence_flow_to_diagram(process_id, gateway_id, end_event_id)
drawer = BpmnDiagramDrawer()
drawer.bpmn_graph = diagram
drawer.draw_diagram(output_path='order_process_diagram.png')
Что происходит: мы создаём процесс "Order Process", добавляем стартовое событие, задачу, условный шлюз (эксклюзивный gateway) и завершающее событие. Затем соединяем элементы стрелками. В итоге получаем изображение диаграммы — понятно и без слов.
BPMN хорош тем, что легко читается — даже менеджер без технического фона поймёт, что происходит в вашем процессе. Кроме того, такая визуализация помогает выявить узкие места и лишнюю логику ещё на этапе проектирования.
Если хочется усложнить сценарий — добавьте участника (пул или дорожку), события сообщений, циклические задачи и параллельные шлюзы. Всё это поддерживается в bpmn-python, хоть и не всегда очевидно — документация скромная. Тем не менее, для генерации базовых бизнес-процессов инструмента достаточно.
В мире, где почти каждый API, микросервис и скрипт становится частью сложного потока, визуализация таких процессов ценится на вес золота. А когда эту визуализацию можно собрать автоматически из Python — это становится частью DevOps-магии.
👍1
Привет, друзья! Сегодня нырнем в мир асинхронности и узнаем, как Python-тюлень превращается в сетевую торпеду благодаря библиотеке asyncio. Если вы когда-либо писали сетевые приложения и сталкивались с болью от блокирующего кода — добро пожаловать в будущее, где одна корутина может сделать больше, чем десять потоков на слабом ноутбуке.
Что же такое asyncio? Это современный подход к асинхронному программированию в Python. Он позволяет запускать несколько задач одновременно без реального многопоточия — за счёт кооперативной многозадачности. Это идеальный выбор для I/O-зависимых задач: работы с сетью, файлами, сокетами и базами данных.
Рассмотрим пример простого TCP-сервера, который обрабатывает клиентские соединения асинхронно:
import asyncio
async def handleclient(reader, writer):
addr = writer.getextrainfo('peername')
print(f"Connected: {addr}")
while True:
data = await reader.readline()
if not data:
break
message = data.decode().strip()
print(f"Received from {addr}: {message}")
response = f"Echo: {message}\n"
writer.write(response.encode())
await writer.drain()
print(f"Disconnected: {addr}")
writer.close()
await writer.waitclosed()
async def main():
server = await asyncio.startserver(handleclient, '127.0.0.1', 8888)
addr = server.sockets0.getsockname()
print(f"Serving on {addr}")
async with server:
await server.serveforever()
asyncio.run(main())
Этот код запускает асинхронный TCP-сервер на порту 8888. При подключении клиента создается новая корутина handleclient. Вместо блокирующих операций чтения/записи мы используем await reader.readline() и await writer.drain(), позволяя другим задачам выполняться между ожиданиями.
Чем это лучше, скажете вы? Ну, во-первых — экономия ресурсов. Вместо того чтобы спаунить потоки и платить за переключение контекста (и риск словить GIL), asyncio даёт нам лёгкие задачи внутри одного потока. Во-вторых — читаемость. Вместо колбэков и адской вложенности в стиле JavaScript времён динозавров, у нас есть async/await — лаконично и выразительно.
Допустим, вы хотите написать клиент, который периодически шлёт сообщения серверу:
async def tcpechoclient():
reader, writer = await asyncio.openconnection('127.0.0.1', 8888)
for i in range(5):
message = f"Hello {i}\n"
writer.write(message.encode())
await writer.drain()
response = await reader.readline()
print(f"Received: {response.decode().strip()}")
await asyncio.sleep(1)
writer.close()
await writer.waitclosed()
asyncio.run(tcpechoclient())
Это уже мини-болталка: клиент отправляет сообщения, сервер эхо-отвечает. Всё асинхронно и без блокировок! А если подключатся десятки клиентов? Никаких проблем — asyncio справится, пока вы не начнете жарить процессор тяжёлыми вычислениями. Тут уже стоит подумать об asyncio + multiprocessing или выносить нагрузку в отдельные сервисы.
А как быть с тайм-аутами, отменой задач и очередями? Тут тоже всё продумано: asyncio предоставляет объекты Future, Task и Queue, которые позволяют строить настоящие архитектуры. И, да, в реальных проектах часто используются такие фреймворки, как aiohttp (асинхронный HTTP-сервер и клиент) или websockets — они расширяют возможности asyncio, сохраняя модели async/await.
asyncio — это мощный инструмент, который делает написание сетевых приложений в Python одновременно простым, эффективным и масштабируемым. Если вы до сих пор пишете blocking-сокеты — самое время пересесть на асинхронный экспресс.
До встречи в следующих постах, где мы разберём, как с помощью aiohttp строить REST API, не теряя скорости даже под нагрузкой.
Что же такое asyncio? Это современный подход к асинхронному программированию в Python. Он позволяет запускать несколько задач одновременно без реального многопоточия — за счёт кооперативной многозадачности. Это идеальный выбор для I/O-зависимых задач: работы с сетью, файлами, сокетами и базами данных.
Рассмотрим пример простого TCP-сервера, который обрабатывает клиентские соединения асинхронно:
import asyncio
async def handleclient(reader, writer):
addr = writer.getextrainfo('peername')
print(f"Connected: {addr}")
while True:
data = await reader.readline()
if not data:
break
message = data.decode().strip()
print(f"Received from {addr}: {message}")
response = f"Echo: {message}\n"
writer.write(response.encode())
await writer.drain()
print(f"Disconnected: {addr}")
writer.close()
await writer.waitclosed()
async def main():
server = await asyncio.startserver(handleclient, '127.0.0.1', 8888)
addr = server.sockets0.getsockname()
print(f"Serving on {addr}")
async with server:
await server.serveforever()
asyncio.run(main())
Этот код запускает асинхронный TCP-сервер на порту 8888. При подключении клиента создается новая корутина handleclient. Вместо блокирующих операций чтения/записи мы используем await reader.readline() и await writer.drain(), позволяя другим задачам выполняться между ожиданиями.
Чем это лучше, скажете вы? Ну, во-первых — экономия ресурсов. Вместо того чтобы спаунить потоки и платить за переключение контекста (и риск словить GIL), asyncio даёт нам лёгкие задачи внутри одного потока. Во-вторых — читаемость. Вместо колбэков и адской вложенности в стиле JavaScript времён динозавров, у нас есть async/await — лаконично и выразительно.
Допустим, вы хотите написать клиент, который периодически шлёт сообщения серверу:
async def tcpechoclient():
reader, writer = await asyncio.openconnection('127.0.0.1', 8888)
for i in range(5):
message = f"Hello {i}\n"
writer.write(message.encode())
await writer.drain()
response = await reader.readline()
print(f"Received: {response.decode().strip()}")
await asyncio.sleep(1)
writer.close()
await writer.waitclosed()
asyncio.run(tcpechoclient())
Это уже мини-болталка: клиент отправляет сообщения, сервер эхо-отвечает. Всё асинхронно и без блокировок! А если подключатся десятки клиентов? Никаких проблем — asyncio справится, пока вы не начнете жарить процессор тяжёлыми вычислениями. Тут уже стоит подумать об asyncio + multiprocessing или выносить нагрузку в отдельные сервисы.
А как быть с тайм-аутами, отменой задач и очередями? Тут тоже всё продумано: asyncio предоставляет объекты Future, Task и Queue, которые позволяют строить настоящие архитектуры. И, да, в реальных проектах часто используются такие фреймворки, как aiohttp (асинхронный HTTP-сервер и клиент) или websockets — они расширяют возможности asyncio, сохраняя модели async/await.
asyncio — это мощный инструмент, который делает написание сетевых приложений в Python одновременно простым, эффективным и масштабируемым. Если вы до сих пор пишете blocking-сокеты — самое время пересесть на асинхронный экспресс.
До встречи в следующих постах, где мы разберём, как с помощью aiohttp строить REST API, не теряя скорости даже под нагрузкой.
🔥4
Рекомендации, которые понимают тебя лучше, чем друзья? Звучит как магия! Но на самом деле — это математика и немного Python. Сегодня мы погрузимся в мир рекомендационных систем и узнаем, как с их помощью можно строить персонализированные советы — будь то фильмы, книги или товары. А точнее — разберём один из самых популярных подходов: Collaborative Filtering.
Что такое Collaborative Filtering?
Это метод, который работает по следующей логике: «Если пользователь A и пользователь B оценили много объектов одинаково, то, скорее всего, то, что понравилось B, понравится и A». В этом подходе нет необходимости знать содержимое самих объектов — только поведение пользователей.
В Python есть несколько удобных библиотек для реализации коллаборативной фильтрации. Для базовой версии отлично подойдёт библиотека Surprise (да, именно так называется — она действительно способна удивить).
Установим её:
pip install scikit-surprise
Теперь время кода:
from surprise import Dataset, Reader
from surprise import KNNBasic
from surprise.modelselection import traintestsplit
from surprise import accuracy
# Пример данных: userid, itemid, rating (1–5)
data = Dataset.loadfromdf(
[
("user1", "item1", 5),
("user1", "item2", 3),
("user2", "item1", 4),
("user2", "item3", 2),
("user3", "item2", 4),
("user3", "item3", 5),
],
Reader(ratingscale=(1, 5))
)
trainset, testset = traintestsplit(data, testsize=0.2)
# Модель на основе user-based collaborative filtering
algo = KNNBasic(simoptions={"userbased": True})
algo.fit(trainset)
predictions = algo.test(testset)
# Посмотрим на точность
print(f"RMSE: {accuracy.rmse(predictions):.4f}")
# Предсказать интерес пользователя
userid = "user1"
itemid = "item3"
pred = algo.predict(userid, itemid)
print(f"Predicted rating for {userid} on {itemid}: {pred.est:.2f}")
Что тут происходит? Мы берём искусственный датафрейм с оценками пользователей, делим данные на тренировочные и тестовые, строим модель на K-ближайших соседях, основываясь на схожести пользователей. А потом... начинаем предсказывать, насколько понравится товар user1, если он ещё не взаимодействовал с ним.
Можно легко переключиться на item-based подход, просто поменяв userbased на False — тогда схожесть будет оцениваться между объектами, что тоже иногда даёт отличные результаты.
Этот метод прост, но прекрасно работает на небольших датасетах или как базовая модель. Реальные системы, конечно, используют матричные разложения и глубокие нейронные сети. Но с чего-то ведь нужно начинать, верно?
Так что если вы хотите построить своему пользователю «Netflix в миниатюре» — попробуйте collaborative filtering. Это не так сложно, как кажется, особенно с Python в руках.
Что такое Collaborative Filtering?
Это метод, который работает по следующей логике: «Если пользователь A и пользователь B оценили много объектов одинаково, то, скорее всего, то, что понравилось B, понравится и A». В этом подходе нет необходимости знать содержимое самих объектов — только поведение пользователей.
В Python есть несколько удобных библиотек для реализации коллаборативной фильтрации. Для базовой версии отлично подойдёт библиотека Surprise (да, именно так называется — она действительно способна удивить).
Установим её:
pip install scikit-surprise
Теперь время кода:
from surprise import Dataset, Reader
from surprise import KNNBasic
from surprise.modelselection import traintestsplit
from surprise import accuracy
# Пример данных: userid, itemid, rating (1–5)
data = Dataset.loadfromdf(
[
("user1", "item1", 5),
("user1", "item2", 3),
("user2", "item1", 4),
("user2", "item3", 2),
("user3", "item2", 4),
("user3", "item3", 5),
],
Reader(ratingscale=(1, 5))
)
trainset, testset = traintestsplit(data, testsize=0.2)
# Модель на основе user-based collaborative filtering
algo = KNNBasic(simoptions={"userbased": True})
algo.fit(trainset)
predictions = algo.test(testset)
# Посмотрим на точность
print(f"RMSE: {accuracy.rmse(predictions):.4f}")
# Предсказать интерес пользователя
userid = "user1"
itemid = "item3"
pred = algo.predict(userid, itemid)
print(f"Predicted rating for {userid} on {itemid}: {pred.est:.2f}")
Что тут происходит? Мы берём искусственный датафрейм с оценками пользователей, делим данные на тренировочные и тестовые, строим модель на K-ближайших соседях, основываясь на схожести пользователей. А потом... начинаем предсказывать, насколько понравится товар user1, если он ещё не взаимодействовал с ним.
Можно легко переключиться на item-based подход, просто поменяв userbased на False — тогда схожесть будет оцениваться между объектами, что тоже иногда даёт отличные результаты.
Этот метод прост, но прекрасно работает на небольших датасетах или как базовая модель. Реальные системы, конечно, используют матричные разложения и глубокие нейронные сети. Но с чего-то ведь нужно начинать, верно?
Так что если вы хотите построить своему пользователю «Netflix в миниатюре» — попробуйте collaborative filtering. Это не так сложно, как кажется, особенно с Python в руках.
Вы когда-нибудь оказались в ситуации, когда нужно сгенерировать отчет с сотнями строк данных, а затем каждую неделю обновлять его вручную? Excel зависает, числа в глазах двоятся, а дедлайны дышат в затылок. В такой момент Python становится супергероем офисной автоматизации. Сегодня я покажу, как автоматизировать создание и обновление отчетов с помощью Python — быстро, просто и без боли.
На помощь приходят проверенные бойцы: pandas, openpyxl и matplotlib. Они помогут работать с данными, редактировать Excel-файлы и даже строить графики. Начнем с простого отчета: есть CSV-файл с продажами по регионам, нам нужно собрать сумму продаж, построить график и сохранить всё это в Excel-отчет.
Пример исходных данных в sales.csv:
region,date,sales
North,2024-05-01,1200
South,2024-05-01,950
North,2024-05-02,1340
... и так далее.
Сначала читаем и обрабатываем данные:
Хотим добавить график, чтобы отчет был не только полезный, но и красивый? Без проблем:
Теперь создаем Excel-файл с таблицей и вставляем туда наш график:
Что получилось: из CSV-файла мы автоматически получили сводную таблицу по регионам, построили визуализацию и сохранили все это в виде Excel-файла. Всё генерируется буквально за секунды. Можно запускать этот скрипт каждый день или неделю через планировщик задач — и больше не мучиться с отчетами вручную.
Если добавить немножко логики — например, проверку за какую дату данные, или отправку итогового файла по email через smtplib — автоматизация выходит на новый уровень.
Python не просто сокращает время, он освобождает его. Отчеты, которые раньше отнимали часы, можно теперь генерировать в одно касание. И вместо унылого копирования цифр — больше времени на анализ, развитие и создание чего-то действительно важного.
На помощь приходят проверенные бойцы: pandas, openpyxl и matplotlib. Они помогут работать с данными, редактировать Excel-файлы и даже строить графики. Начнем с простого отчета: есть CSV-файл с продажами по регионам, нам нужно собрать сумму продаж, построить график и сохранить всё это в Excel-отчет.
Пример исходных данных в sales.csv:
region,date,sales
North,2024-05-01,1200
South,2024-05-01,950
North,2024-05-02,1340
... и так далее.
Сначала читаем и обрабатываем данные:
import pandas as pd
data = pd.read_csv("sales.csv", parse_dates=["date"])
summary = data.groupby("region")["sales"].sum().reset_index()
Хотим добавить график, чтобы отчет был не только полезный, но и красивый? Без проблем:
import matplotlib.pyplot as plt
plt.figure(figsize=(6, 4))
plt.bar(summary["region"], summary["sales"], color="skyblue")
plt.title("Sales by Region")
plt.xlabel("Region")
plt.ylabel("Total Sales")
plt.tight_layout()
plt.savefig("sales_chart.png")
plt.close()
Теперь создаем Excel-файл с таблицей и вставляем туда наш график:
from openpyxl import Workbook
from openpyxl.drawing.image import Image
from openpyxl.utils.dataframe import dataframe_to_rows
wb = Workbook()
ws = wb.active
ws.title = "Sales Report"
# Вставляем таблицу
for row in dataframe_to_rows(summary, index=False, header=True):
ws.append(row)
# Вставляем картинку с графиком
img = Image("sales_chart.png")
img.anchor = "E2" # координаты вставки
ws.add_image(img)
wb.save("sales_report.xlsx")
Что получилось: из CSV-файла мы автоматически получили сводную таблицу по регионам, построили визуализацию и сохранили все это в виде Excel-файла. Всё генерируется буквально за секунды. Можно запускать этот скрипт каждый день или неделю через планировщик задач — и больше не мучиться с отчетами вручную.
Если добавить немножко логики — например, проверку за какую дату данные, или отправку итогового файла по email через smtplib — автоматизация выходит на новый уровень.
Python не просто сокращает время, он освобождает его. Отчеты, которые раньше отнимали часы, можно теперь генерировать в одно касание. И вместо унылого копирования цифр — больше времени на анализ, развитие и создание чего-то действительно важного.
👍1
Когда дело доходит до обработки изображений, Python уже давно считается мощным инструментом: PIL, OpenCV, NumPy — все это знакомо многим. Но что, если скорость критична, а массивы пикселей требуют обработки параллельно? Добро пожаловать в мир OpenCL.
OpenCL (Open Computing Language) — это фреймворк для написания программ, которые исполняются на гетерогенных устройствах: CPU, GPU и других ускорителях. Да, это немного ближе к низкому уровню, но Python умеет работать с этим элегантно благодаря библиотеке PyOpenCL.
Сегодня мы разберем, как писать простой код на Python для обработки изображения с использованием OpenCL: от чтения файла до применения фильтра размытия с GPU.
Установка PyOpenCL:
pip install pyopencl Pillow numpy
Пример: фильтр размытия изображения.
Начнем с загрузки изображения и подготовки его к обработке:
from PIL import Image
import pyopencl as cl
import numpy as np
# Загрузка изображения
img = Image.open("input.jpg").convert("L") # Преобразуем в оттенки серого
imgarray = np.array(img).astype(np.uint8)
height, width = imgarray.shape
# Подготовка выходного массива
resultarray = np.emptylike(imgarray)
Теперь создаем контекст OpenCL и компилируем ядро:
ctx = cl.createsomecontext()
queue = cl.CommandQueue(ctx)
# OpenCL-ядро для размытия
kernelcode = """
kernel void blurimage(global const uchar *input,
global uchar *output,
const int width,
const int height) {
int x = getglobalid(0);
int y = getglobalid(1);
int idx = y * width + x;
if (x > 0 && y > 0 && x < width - 1 && y < height - 1) {
int sum = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
int nx = x + dx;
int ny = y + dy;
sum += input[ny * width + nx];
}
output[idx] = sum / 9;
} else {
output[idx] = input[idx];
}
}
"""
program = cl.Program(ctx, kernelcode).build()
# Создание буферов
mf = cl.memflags
inputbuf = cl.Buffer(ctx, mf.READONLY | mf.COPYHOSTPTR, hostbuf=imgarray)
outputbuf = cl.Buffer(ctx, mf.WRITEONLY, resultarray.nbytes)
# Запуск ядра
program.blurimage(queue, (width, height), None,
inputbuf, outputbuf,
np.int32(width), np.int32(height))
# Копирование результата обратно
cl.enqueuecopy(queue, resultarray, outputbuf)
# Сохранение выходного изображения
Image.fromarray(resultarray).save("output.jpg")
Что мы сделали:
- Считали изображение и преобразовали в массив.
- Подали его в ядро OpenCL, в котором политики памяти максимально эффективны.
- Обработали каждый пиксель параллельно, благодаря GPU.
- Получили примерно в 10-20 раз более быструю обработку по сравнению с чистым Python.
Почему это важно?
Когда вы имеете дело с изображениями высокого разрешения, производительность становится критична. Даже простое размытие может занимать секунды. OpenCL позволяет разгрузить CPU, переложив вычисления на GPU, даже встроенный.
К тому же, PyOpenCL — это не просто мост между Python и OpenCL. Он предоставляет удобные средства работы с памятью, компиляцией и управления устройствами.
Заключение
Если вы работаете с изображениями и чувствуете, что Python не справляется, не спешите уходить к C++. PyOpenCL — мощный способ ускорить вычисления, не теряя гибкости Python. Попробуйте, результат вас удивит.
OpenCL (Open Computing Language) — это фреймворк для написания программ, которые исполняются на гетерогенных устройствах: CPU, GPU и других ускорителях. Да, это немного ближе к низкому уровню, но Python умеет работать с этим элегантно благодаря библиотеке PyOpenCL.
Сегодня мы разберем, как писать простой код на Python для обработки изображения с использованием OpenCL: от чтения файла до применения фильтра размытия с GPU.
Установка PyOpenCL:
pip install pyopencl Pillow numpy
Пример: фильтр размытия изображения.
Начнем с загрузки изображения и подготовки его к обработке:
from PIL import Image
import pyopencl as cl
import numpy as np
# Загрузка изображения
img = Image.open("input.jpg").convert("L") # Преобразуем в оттенки серого
imgarray = np.array(img).astype(np.uint8)
height, width = imgarray.shape
# Подготовка выходного массива
resultarray = np.emptylike(imgarray)
Теперь создаем контекст OpenCL и компилируем ядро:
ctx = cl.createsomecontext()
queue = cl.CommandQueue(ctx)
# OpenCL-ядро для размытия
kernelcode = """
kernel void blurimage(global const uchar *input,
global uchar *output,
const int width,
const int height) {
int x = getglobalid(0);
int y = getglobalid(1);
int idx = y * width + x;
if (x > 0 && y > 0 && x < width - 1 && y < height - 1) {
int sum = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
int nx = x + dx;
int ny = y + dy;
sum += input[ny * width + nx];
}
output[idx] = sum / 9;
} else {
output[idx] = input[idx];
}
}
"""
program = cl.Program(ctx, kernelcode).build()
# Создание буферов
mf = cl.memflags
inputbuf = cl.Buffer(ctx, mf.READONLY | mf.COPYHOSTPTR, hostbuf=imgarray)
outputbuf = cl.Buffer(ctx, mf.WRITEONLY, resultarray.nbytes)
# Запуск ядра
program.blurimage(queue, (width, height), None,
inputbuf, outputbuf,
np.int32(width), np.int32(height))
# Копирование результата обратно
cl.enqueuecopy(queue, resultarray, outputbuf)
# Сохранение выходного изображения
Image.fromarray(resultarray).save("output.jpg")
Что мы сделали:
- Считали изображение и преобразовали в массив.
- Подали его в ядро OpenCL, в котором политики памяти максимально эффективны.
- Обработали каждый пиксель параллельно, благодаря GPU.
- Получили примерно в 10-20 раз более быструю обработку по сравнению с чистым Python.
Почему это важно?
Когда вы имеете дело с изображениями высокого разрешения, производительность становится критична. Даже простое размытие может занимать секунды. OpenCL позволяет разгрузить CPU, переложив вычисления на GPU, даже встроенный.
К тому же, PyOpenCL — это не просто мост между Python и OpenCL. Он предоставляет удобные средства работы с памятью, компиляцией и управления устройствами.
Заключение
Если вы работаете с изображениями и чувствуете, что Python не справляется, не спешите уходить к C++. PyOpenCL — мощный способ ускорить вычисления, не теряя гибкости Python. Попробуйте, результат вас удивит.
Многоязычие в Django: как заставить ваше приложение "говорить" по-английски, по-русски и не только
Создаёте веб-приложение и хотите, чтобы им пользовались люди со всего мира? Добро пожаловать в мульти-языковой мир Django. Этот фреймворк предоставляет полноценные средства для локализации интерфейсов — от перевода текстов до управления пользовательскими языковыми настройками. Ниже — конкретно и без воды о том, как всё это настроить.
🔹 Шаг 1: Включим поддержку перевода
В
Параметр
🔹 Шаг 2: Готовим строки к переводу
Все строки, которые должны быть переведены, нужно пометить специальными функциями. Django предоставляет
Пример в шаблоне:
Пример в Python-коде:
🔹 Шаг 3: Собираем переводимые строки
После пометок — соберём все строки для перевода. Выполняем команду:
В результате появится файл
🔹 Шаг 4: Компилируем переводы
Чтобы Django мог использовать переведённые строки, необходимо скомпилировать
Теперь переводы готовы к использованию.
🔹 Шаг 5: Автоматическое определение языка
Добавьте
Этот middleware анализирует заголовки браузера или куки и подставляет нужный язык.
Хотите переключать язык вручную? Создайте URL:
Теперь URL-адрес будет содержать префикс языка (
🔹 Шаг 6: Динамическое переключение языка
Можно переключать язык прямо во время выполнения, например, через форму или селектор:
🎉 Готово!
Теперь ваше Django-приложение умеет "разговаривать" на нескольких языках. Это открывает дорогу к глобальному рынку и делает интерфейс дружелюбнее к пользователю.
Локализация в Django — это не просто nice-to-have. Это must-have, если вы хотите выйти за пределы одного языка. Делая ваш сайт многоязычным, вы делаете его доступным. А значит — полезным.
Создаёте веб-приложение и хотите, чтобы им пользовались люди со всего мира? Добро пожаловать в мульти-языковой мир Django. Этот фреймворк предоставляет полноценные средства для локализации интерфейсов — от перевода текстов до управления пользовательскими языковыми настройками. Ниже — конкретно и без воды о том, как всё это настроить.
🔹 Шаг 1: Включим поддержку перевода
В
settings.py активируем интернационализацию:USE_I18N = True
USE_L10N = True
LANGUAGE_CODE = 'en'
LANGUAGES = [
('en', 'English'),
('ru', 'Russian'),
]
LOCALE_PATHS = [
BASE_DIR / 'locale',
]
Параметр
LANGUAGES важен — это список поддерживаемых языков. Именно здесь вы определяете, на какие языки будет переведён ваш интерфейс.🔹 Шаг 2: Готовим строки к переводу
Все строки, которые должны быть переведены, нужно пометить специальными функциями. Django предоставляет
gettext() и gettext_lazy() (чаще используется ugettext_lazy, но начиная с Django 4.0 используется просто gettext_lazy).Пример в шаблоне:
<h1>{% trans "Welcome to my website!" %}</h1>
Пример в Python-коде:
from django.utils.translation import gettext_lazy as _
class Product(models.Model):
name = models.CharField(max_length=100, verbose_name=_("Product Name"))
🔹 Шаг 3: Собираем переводимые строки
После пометок — соберём все строки для перевода. Выполняем команду:
django-admin makemessages -l ru
В результате появится файл
locale/ru/LC_MESSAGES/django.po. Именно в нём вы вписываете переводы:msgid "Welcome to my website!"
msgstr "Добро пожаловать на мой сайт!"
🔹 Шаг 4: Компилируем переводы
Чтобы Django мог использовать переведённые строки, необходимо скомпилировать
.po в .mo:django-admin compilemessages
Теперь переводы готовы к использованию.
🔹 Шаг 5: Автоматическое определение языка
Добавьте
LocaleMiddleware в MIDDLEWARE:MIDDLEWARE = [
# ...
'django.middleware.locale.LocaleMiddleware',
# ...
]
Этот middleware анализирует заголовки браузера или куки и подставляет нужный язык.
Хотите переключать язык вручную? Создайте URL:
from django.conf.urls.i18n import i18n_patterns
urlpatterns = i18n_patterns(
path('admin/', admin.site.urls),
path('products/', include('products.urls')),
)
Теперь URL-адрес будет содержать префикс языка (
/ru/products/), а Django подстроится под локаль.🔹 Шаг 6: Динамическое переключение языка
Можно переключать язык прямо во время выполнения, например, через форму или селектор:
from django.utils import translation
def set_language_view(request):
user_language = 'ru'
translation.activate(user_language)
response = HttpResponse("Привет!")
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
return response
🎉 Готово!
Теперь ваше Django-приложение умеет "разговаривать" на нескольких языках. Это открывает дорогу к глобальному рынку и делает интерфейс дружелюбнее к пользователю.
Локализация в Django — это не просто nice-to-have. Это must-have, если вы хотите выйти за пределы одного языка. Делая ваш сайт многоязычным, вы делаете его доступным. А значит — полезным.
🚀 Микросервисы на Python: как всё устроено?
В последние годы микросервисная архитектура стала настоящим мейнстримом. Неудивительно — она даёт масштабируемость, гибкость в разработке и возможность легко поддерживать большие системы. Сегодня мы разберемся, как создаются микросервисы на Python, какие инструменты стоит использовать и с какими нюансами ты столкнёшься на практике.
🔧 Что такое микросервисы?
Если коротко — микросервисная архитектура подразумевает разделение приложения на отдельные, автономные сервисы. Каждый из них выполняет небольшую, четко определённую задачу и взаимодействует с остальными через API, обычно по HTTP или через очередь сообщений. В отличие от монолита, где всё связано, микросервисы «разведены» по своим зонам ответственности, что позволяет им развиваться независимо.
🎯 Почему Python?
Python отлично подходит для микросервисов благодаря своей лаконичности, огромному количеству библиотек и фреймворков, а также простоте интеграции с современными DevOps-инструментами и брокерами сообщений.
🔥 Основные инструменты
Рассмотрим три популярных подхода к созданию микросервисов на Python.
1. Flask/FastAPI — REST API сервисы
Для простых REST-сервисов FastAPI — просто бомба. Он быстрый (благодаря ASGI), прост в использовании и умеет сам генерировать документацию (Swagger, ReDoc).
Пример простого микросервиса:
Такой сервис легко развернуть, протестировать или масштабировать.
2. Celery + Redis/RabbitMQ — асинхронные задачи
Если ты хочешь, чтобы один микросервис "бросал задание", а другой — "его делал", без ожидания, пригодится Celery. Пример с использованием Redis:
worker.py
caller.py
Celery превращает Python-функции в асинхронные задачи, которые можно распределять между машинами и масштабировать.
3. gRPC — бинарный, быстрый, строгий
Для микросервисов с высоким трафиком, строгими контрактами и необходимостью работать быстро — gRPC отличное решение. Он использует Protocol Buffers вместо JSON и позволяет создавать строго типизированные API.
Пример на базе библиотек grpcio и protobuf выходит чуть длиннее, но даёт большой выигрыш в производительности и безопасности.
👀 Взаимодействие микросервисов
Варианты связки сервисов:
- HTTP-запросы (Flask/FastAPI)
- Очереди сообщений (RabbitMQ, Kafka, Redis Streams)
- gRPC
- GraphQL gateway
Для оркестрации и развертывания чаще всего используют Docker и Kubernetes.
🧩 Где подводные камни?
- Сложность: микросервисы — это дополнительная логика: деплой, мониторинг, логирование, безопасность.
- Сетевые накладные расходы.
- Управление версиями API.
Тем не менее, если архитектура продумана и под задачи системы микросервисы подходят — Python обеспечит тебе мощный и гибкий стек.
📦 Заключение
Python и микросервисы — отличная пара. Благодаря таким фреймворкам, как FastAPI, Celery и gRPC, ты можешь легко строить масштабируемые и надёжные системы. Вопрос только в задачах и грамотном проектировании — всё остальное уже есть в твоем распоряжении.
Следующий шаг — выбирать инструменты под конкретную задачу и не забывать про тестирование и наблюдаемость (observability). Удачного микросервисинга! 💡
В последние годы микросервисная архитектура стала настоящим мейнстримом. Неудивительно — она даёт масштабируемость, гибкость в разработке и возможность легко поддерживать большие системы. Сегодня мы разберемся, как создаются микросервисы на Python, какие инструменты стоит использовать и с какими нюансами ты столкнёшься на практике.
🔧 Что такое микросервисы?
Если коротко — микросервисная архитектура подразумевает разделение приложения на отдельные, автономные сервисы. Каждый из них выполняет небольшую, четко определённую задачу и взаимодействует с остальными через API, обычно по HTTP или через очередь сообщений. В отличие от монолита, где всё связано, микросервисы «разведены» по своим зонам ответственности, что позволяет им развиваться независимо.
🎯 Почему Python?
Python отлично подходит для микросервисов благодаря своей лаконичности, огромному количеству библиотек и фреймворков, а также простоте интеграции с современными DevOps-инструментами и брокерами сообщений.
🔥 Основные инструменты
Рассмотрим три популярных подхода к созданию микросервисов на Python.
1. Flask/FastAPI — REST API сервисы
Для простых REST-сервисов FastAPI — просто бомба. Он быстрый (благодаря ASGI), прост в использовании и умеет сам генерировать документацию (Swagger, ReDoc).
Пример простого микросервиса:
from fastapi import FastAPI
app = FastAPI()
@app.get("/ping")
def ping():
return {"message": "pong"}
Такой сервис легко развернуть, протестировать или масштабировать.
2. Celery + Redis/RabbitMQ — асинхронные задачи
Если ты хочешь, чтобы один микросервис "бросал задание", а другой — "его делал", без ожидания, пригодится Celery. Пример с использованием Redis:
worker.py
from celery import Celery
app = Celery('tasks', broker='redis://localhost:6379/0')
@app.task
def add_numbers(a, b):
return a + b
caller.py
from worker import add_numbers
result = add_numbers.delay(3, 5)
print(result.get())
Celery превращает Python-функции в асинхронные задачи, которые можно распределять между машинами и масштабировать.
3. gRPC — бинарный, быстрый, строгий
Для микросервисов с высоким трафиком, строгими контрактами и необходимостью работать быстро — gRPC отличное решение. Он использует Protocol Buffers вместо JSON и позволяет создавать строго типизированные API.
Пример на базе библиотек grpcio и protobuf выходит чуть длиннее, но даёт большой выигрыш в производительности и безопасности.
👀 Взаимодействие микросервисов
Варианты связки сервисов:
- HTTP-запросы (Flask/FastAPI)
- Очереди сообщений (RabbitMQ, Kafka, Redis Streams)
- gRPC
- GraphQL gateway
Для оркестрации и развертывания чаще всего используют Docker и Kubernetes.
🧩 Где подводные камни?
- Сложность: микросервисы — это дополнительная логика: деплой, мониторинг, логирование, безопасность.
- Сетевые накладные расходы.
- Управление версиями API.
Тем не менее, если архитектура продумана и под задачи системы микросервисы подходят — Python обеспечит тебе мощный и гибкий стек.
📦 Заключение
Python и микросервисы — отличная пара. Благодаря таким фреймворкам, как FastAPI, Celery и gRPC, ты можешь легко строить масштабируемые и надёжные системы. Вопрос только в задачах и грамотном проектировании — всё остальное уже есть в твоем распоряжении.
Следующий шаг — выбирать инструменты под конкретную задачу и не забывать про тестирование и наблюдаемость (observability). Удачного микросервисинга! 💡
Привет, друзья! Сегодня мы с вами заглянем под капот одного из самых интересных применений Python – создание собственных чат-ботов с помощью Natural Language Processing (NLP). Да, тех самых "ботиков", которые понимают речь, здороваются, отвечают на вопросы и даже могут разрядить неловкую паузу в чате.
Сразу озвучу честно: мы не будем сейчас писать конкуренту ChatGPT — это немного другой уровень. Но понять, как создаются простые персонализированные чат-боты на Python, — вполне по силам даже начинающему разработчику.
Итак, для начала нам понадобятся следующие инструменты:
- библиотека nltk — для базовой обработки человеческой речи;
- библиотека random — чтобы бот не казался шаблонным;
- немного Python-мозгов — оно у вас точно есть ;)
Установка нужных библиотек:
Импортируем всё, что нужно, и подгрузим ресурсы:
Теперь разберёмся с основой: Chat в nltk работает по принципу паттерн-ответ. То есть, когда бот видит "привет", он ищет подходящий шаблон и отвечает заготовленной фразой.
Создадим набор диалогов:
Если вы заметили, шаблоны — это регулярные выражения. Они ловят фразы, похожие на заданный паттерн. Это просто, но мощно! Последний шаблон
Теперь создаём и запускаем нашего чат-бота:
Кстати, переменная
Что можно улучшить?
1. Добавить понимание эмоций: анализировать тональность текста, например, с помощью TextBlob.
2. Интегрировать с Telegram, Discord или веб-интерфейсом.
3. Хранить историю диалога, "тренировать" бота под вашу специфику.
Создание собственного NLP-бота — это как завести ручного интеллекта: вы растите его сами, программируя каждую реакцию. Это отличный способ прокачать свои навыки Python, регулярных выражений и понимания языка.
Впереди ещё много интересного: препроцессинг текста, машинное обучение, векторизации фраз — но об этом в следующих постах. А пока — вперед, создать своего первого "говоруна"! 🧠🤖
Сразу озвучу честно: мы не будем сейчас писать конкуренту ChatGPT — это немного другой уровень. Но понять, как создаются простые персонализированные чат-боты на Python, — вполне по силам даже начинающему разработчику.
Итак, для начала нам понадобятся следующие инструменты:
- библиотека nltk — для базовой обработки человеческой речи;
- библиотека random — чтобы бот не казался шаблонным;
- немного Python-мозгов — оно у вас точно есть ;)
Установка нужных библиотек:
pip install nltk
Импортируем всё, что нужно, и подгрузим ресурсы:
import nltk
import random
from nltk.chat.util import Chat, reflections
nltk.download('punkt')
Теперь разберёмся с основой: Chat в nltk работает по принципу паттерн-ответ. То есть, когда бот видит "привет", он ищет подходящий шаблон и отвечает заготовленной фразой.
Создадим набор диалогов:
pairs = [
[
r"привет|здравствуй|хай",
["Привет!", "Здравствуйте!", "Хаюшки :)"]
],
[
r"как дела\??",
["Всё отлично, а у тебя?", "Лучше не бывает!", "Пишу код, как обычно!"]
],
[
r"что ты умеешь\??",
["Я умею болтать и поддерживать диалог, как любой вежливый бот.",
"Моя задача — делать твоё общение с компьютером чуть приятнее."]
],
[
r"пока|до свидания",
["Пока-пока!", "До встречи!", "Счастливо!"]
],
[
r"(.*)",
["Извини, я пока не знаю, как на это ответить.",
"Попробуй переформулировать вопрос.",
"Интересно… но не совсем понятно :)"]
]
]
Если вы заметили, шаблоны — это регулярные выражения. Они ловят фразы, похожие на заданный паттерн. Это просто, но мощно! Последний шаблон
r"(.*)" — запасной план, "уловка на всё", если бот не понял, что вы сказали.Теперь создаём и запускаем нашего чат-бота:
def run_bot():
print("Привет! Я — твой простой NLP-бот. Напиши что-нибудь, чтобы начать (или 'пока' для выхода).")
chat = Chat(pairs, reflections)
chat.converse()
run_bot()
Кстати, переменная
reflections — это словарь с заменами типа "я" -> "ты", "мой" -> "твой", что делает диалог чуть-чуть более персонализированным. Хотите больше — можно под себя переписать.Что можно улучшить?
1. Добавить понимание эмоций: анализировать тональность текста, например, с помощью TextBlob.
2. Интегрировать с Telegram, Discord или веб-интерфейсом.
3. Хранить историю диалога, "тренировать" бота под вашу специфику.
Создание собственного NLP-бота — это как завести ручного интеллекта: вы растите его сами, программируя каждую реакцию. Это отличный способ прокачать свои навыки Python, регулярных выражений и понимания языка.
Впереди ещё много интересного: препроцессинг текста, машинное обучение, векторизации фраз — но об этом в следующих постах. А пока — вперед, создать своего первого "говоруна"! 🧠🤖
Привет! Сегодня разберёмся с тем, как легко и просто создавать графические интерфейсы на Python с помощью библиотеки PySimpleGUI.
Если вас пугают слова вроде "Qt", "Tkinter" или "canvas", вы не одиноки. Многие считают, что GUI на Python — это сложно, громоздко и требует много времени. Но PySimpleGUI с этим не согласен. Его девиз — «сделай быстро и просто». Он оборачивает популярные GUI-библиотеки (Tkinter, Qt, WxPython, Remi) в простой, читаемый интерфейс. Это буквально Python-код, который читается как псевдоязык.
Давайте не терять время и перейдём к практике.
Установка
Для начала установим библиотеку:
Пример 1. Первое окно "Hello, world!"
Создадим базовое окно с кнопкой и текстом:
Здесь
Пример 2. Простая форма ввода
Теперь создадим мини-приложение, которое спрашивает имя пользователя и приветствует его:
Обратите внимание: каждое поле можно идентифицировать по ключу (
Пример 3. Сохранение файла
А теперь добавим диалог сохранения файла, который можно встроить в любое приложение:
Это уже ближе к реальному приложению. PySimpleGUI позволяет ловко подключать файловые диалоги и другие "взрослые" функции без лишней боли.
Что мне особенно нравится — вы можете быстро собрать интерфейс, протестировать логику, и на лету вносить изменения. У PySimpleGUI отличный встроенный отладочный вывод — вы всегда видите, что возвращает
Заключение
PySimpleGUI — это отличный выбор для скриптов и приложений, которым нужен лёгкий интерфейс без тяжёлых зависимостей и лишней сложности. Он идеально подойдёт для прототипов, утилит, внутренних инструментов.
Если вы только начинаете знакомство с GUI-разработкой — PySimpleGUI даст вам мягкий старт и хороший фундамент.
Если вас пугают слова вроде "Qt", "Tkinter" или "canvas", вы не одиноки. Многие считают, что GUI на Python — это сложно, громоздко и требует много времени. Но PySimpleGUI с этим не согласен. Его девиз — «сделай быстро и просто». Он оборачивает популярные GUI-библиотеки (Tkinter, Qt, WxPython, Remi) в простой, читаемый интерфейс. Это буквально Python-код, который читается как псевдоязык.
Давайте не терять время и перейдём к практике.
Установка
Для начала установим библиотеку:
pip install PySimpleGUI
Пример 1. Первое окно "Hello, world!"
Создадим базовое окно с кнопкой и текстом:
import PySimpleGUI as sg
layout = [
[sg.Text("Hello, world!")],
[sg.Button("OK")]
]
window = sg.Window("My First Window", layout)
while True:
event, values = window.read()
if event == sg.WINDOW_CLOSED or event == "OK":
break
window.close()
Здесь
layout — это список, описывающий содержимое окна построчно. Всё элементарно: текстовая метка и кнопка.Пример 2. Простая форма ввода
Теперь создадим мини-приложение, которое спрашивает имя пользователя и приветствует его:
import PySimpleGUI as sg
layout = [
[sg.Text("What's your name?")],
[sg.Input(key="name")],
[sg.Button("Submit")],
[sg.Text("", size=(30, 1), key="output")]
]
window = sg.Window("Name App", layout)
while True:
event, values = window.read()
if event == sg.WINDOW_CLOSED:
break
if event == "Submit":
name = values["name"]
window["output"].update(f"Hello, {name}!")
window.close()
Обратите внимание: каждое поле можно идентифицировать по ключу (
key), а затем обновлять или извлекать значение через values.Пример 3. Сохранение файла
А теперь добавим диалог сохранения файла, который можно встроить в любое приложение:
import PySimpleGUI as sg
layout = [
[sg.Text("Save your file:")],
[sg.InputText(key="filepath"), sg.FileSaveAs()],
[sg.Button("Save"), sg.Button("Exit")]
]
window = sg.Window("File Saver", layout)
while True:
event, values = window.read()
if event in (sg.WINDOW_CLOSED, "Exit"):
break
if event == "Save" and values["filepath"]:
with open(values["filepath"], "w") as f:
f.write("Some example content.")
window.close()
Это уже ближе к реальному приложению. PySimpleGUI позволяет ловко подключать файловые диалоги и другие "взрослые" функции без лишней боли.
Что мне особенно нравится — вы можете быстро собрать интерфейс, протестировать логику, и на лету вносить изменения. У PySimpleGUI отличный встроенный отладочный вывод — вы всегда видите, что возвращает
read() и какие события происходят.Заключение
PySimpleGUI — это отличный выбор для скриптов и приложений, которым нужен лёгкий интерфейс без тяжёлых зависимостей и лишней сложности. Он идеально подойдёт для прототипов, утилит, внутренних инструментов.
Если вы только начинаете знакомство с GUI-разработкой — PySimpleGUI даст вам мягкий старт и хороший фундамент.