Python для начинающих

Как использовать Flask-Security для добавления безопасности в веб-приложения

Привет, друзья! Сегодня у нас в блоге отличная тема: поговорим о работе с географическими данными с помощью библиотеки Fiona. Часто, когда речь заходит о ГИС-данных (географических информационных системах), большинство вспоминает тяжеловесные инструменты вроде ArcGIS или QGIS. Но если вам нужно быстро прочитать shapefile, извлечь нужные геометрии и метаданные, преобразовать их — Python с его библиотекой Fiona делает это элегантно и без лишнего шума. Что такое Fiona? В двух словах — это библиотека для работы с геопространственными файлами через Python в стиле "сущности-объекты". Она строится поверх библиотеки GDAL/OGR, но обёрнута в удобный, Python-овый интерфейс. ### Установка Стандартно через pip:

pip install fiona

Важно: GDAL должен быть установлен до этого. На Windows проще всего поставить всё через Conda. --- ### Пример 1: Читаем shapefile Допустим, у нас есть shapefile с пунктами мониторинга воздуха. Считаем его:

import fiona

with fiona.open('air_quality_stations.shp') as shp:
    for feature in shp:
        print(feature['properties'])
        print(feature['geometry'])

Что происходит? - feature — это одна запись в файле: свойства точки (например, имя станции) и геометрия (координаты). - Свойства хранятся в словаре properties, а форма данных (точка, линия, полигон) — в geometry. --- ### Пример 2: Создаём новый geo-файл Хотите создать свой собственный shapefile из программы? Fiona тоже здесь пригодится.

import fiona
from shapely.geometry import mapping, Point

schema = {
    'geometry': 'Point',
    'properties': {'name': 'str'}
}

points = [
    {'name': 'Station A', 'coordinates': (102.0, 0.5)},
    {'name': 'Station B', 'coordinates': (103.0, 1.0)}
]

with fiona.open(
    'new_stations.shp', 
    mode='w',
    driver='ESRI Shapefile',
    schema=schema,
    crs='EPSG:4326'
) as shp:
    for point in points:
        geom = Point(point['coordinates'])
        shp.write({
            'geometry': mapping(geom),
            'properties': {'name': point['name']}
        })

Здесь: - Мы задали схему файла: каждый объект — точка + одно текстовое поле name. - Для каждой точки создаём геометрию через библиотеку Shapely (mapping превращает объект в формат GeoJSON). --- ### Пример 3: Фильтрация объектов Иногда нужно выбрать только некоторые объекты по условиям:

import fiona

with fiona.open('air_quality_stations.shp') as shp:
    selected = [f for f in shp if f['properties']['city'] == 'Moscow']
    print(f"Found {len(selected)} stations in Moscow")

Быстро и лаконично. --- ### Чем ещё полезна Fiona? - Поддерживает множество форматов: GeoPackage (.gpkg), GeoJSON, Shapefile и др. - Читает данные постранично, без загрузки всего файла в память — важно для тяжёлых архивов. - Работает в паре с другими библиотеками — например, вместе с Shapely и Rasterio делает магию геообработки. Ключевая идея Fiona — "не ломай данные". Она напрямую передаёт вам GeoJSON-подобные объекты без преобразований, тем самым избавляя вас от сюрпризов при чтении/записи. --- Fiona — основной инструмент, если стартовать работу с ГИС-данными через Python. Минимализм, устойчивость и логичность — вот за что её любят разработчики. На следующем шаге рекомендую попробовать связать работу Fiona с визуализацией через Folium или обработкой пространственных запросов через GeoPandas. Но об этом как-нибудь в отдельном посте! До скорого! 🚀

Работа с геопространственными данными с использованием библиотеки Fiona

🚀 --- Хочешь, могу сразу предложить тебе идеи для следующих постов в таком же стиле!

# Настройка и использование Apache Kafka для обработки событий с Python Привет, друзья! Сегодня у нас на очереди одна из самых интересных тем — подключение Python к Apache Kafka. Если раньше ты считал, что Kafka — это только для больших компаний и бородатых архитекторах с диаграммами в руках, то готовься: сейчас мы её приручим и начнем использовать буквально в несколько строк кода. ## Что такое Apache Kafka? Kafka — это распределённая платформа для потоковой передачи сообщений. Грубо говоря, она позволяет одной части вашей системы быстро сообщать события другой части. Представь это как сверхбыстрый почтовый сервис для данных в реальном времени. ## Установка Kafka (локально) Для локальной установки понадобится Java и собственно Kafka. Если у тебя установлен Docker, развернуть Kafka можно буквально в две команды:

docker network create kafka-net

docker run -d --name zookeeper --network kafka-net -e ALLOW_ANONYMOUS_LOGIN=yes bitnami/zookeeper:latest

docker run -d --name kafka --network kafka-net -e KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181 -e ALLOW_ANONYMOUS_LOGIN=yes -p 9092:9092 bitnami/kafka:latest

Это поднимет Zookeeper и Kafka сервер локально на порте 9092. ## Установка Python-клиента Kafka сама по себе не разговаривает на Python. Нам поможет библиотека kafka-python. Устанавливаем ее:

pip install kafka-python

Готово! Теперь пишем наш первый продюсер и консьюмер сообщений. ## Отправка сообщений в Kafka Создадим продюсера, который будет отправлять события в топик test-topic:

from kafka import KafkaProducer

producer = KafkaProducer(bootstrap_servers='localhost:9092')

for i in range(5):
    message = f"Hello Kafka {i}"
    producer.send('test-topic', message.encode('utf-8'))
    print(f"Sent: {message}")

producer.flush()

Обрати внимание, Kafka ожидает отправку байтов, поэтому .encode('utf-8') обязательно. ## Получение сообщений из Kafka А теперь консьюмер, который будет эти сообщения забирать:

from kafka import KafkaConsumer

consumer = KafkaConsumer(
    'test-topic',
    bootstrap_servers='localhost:9092',
    auto_offset_reset='earliest',  # берем всё с начала
    enable_auto_commit=True,
    group_id='test-group'
)

for message in consumer:
    print(f"Received: {message.value.decode('utf-8')}")

И вот ты уже слушаешь свой первый поток данных в реальном времени! ## Пара моментов, которые стоит знать: - Топики и партиции — данные в Kafka не просто в одном потоке, они разбиваются на "топики", а внутри топиков — еще и на "партиции". Это даёт масштабируемость и отказоустойчивость. - Консьюмер-группы — если несколько приложений читают данные из одного топика в одной группе, Kafka сама балансирует нагрузку между ними. - Брокеры — один экземпляр Kafka называется брокером. Несколько брокеров можно объединить в кластер для масштабирования. - Производитель (Producer) и Потребитель (Consumer) — фундаментальные роли в любой системе на Kafka. ## Когда стоит использовать Kafka? - Если твои данные нужно обрабатывать в реальном времени. - Когда у тебя много источников событий (например, клики на сайте, заказы в магазине, сенсорные данные). - Для построения надёжных очередей сообщений между микросервисами. ## Пара советов для продвинутой работы: - На продакшн используют более надёжные библиотеки, например confluent-kafka-python, основанную на C-библиотеке — она быстрее. - На старте важно правильно настроить параметры продюсера (например, acks или retries), чтобы не терять сообщения. - Kafka прекрасно скейлится горизонтально. Добавлять брокеры просто — как складывать кубики Lego. --- На этом всё! Сегодня мы сделали серьёзный шаг в мир потоковой обработки данных. Теперь ты умеешь не только писать скрипты, но и строить настоящие события в реальном времени. До встречи в новых статьях — дальше будет ещё интереснее!

Настройка и использование Apache Kafka для обработки событий с Python

Как создать симулятор физических процессов с использованием Python и PhysX

Моя книга по саморазвитию https://books.yandex.ru/books/jhuoVJyP

Привет! Сегодня поговорим о настоящем монстре в мире больших данных — PySpark. Если вы когда-либо работали с pandas, вы наверняка влюбились в удобство работы с DataFrame. Но однажды наступает момент, когда данных становится слишком много: говорим уже не о десятках тысяч строк, а о миллионах и миллиардах. Вот тут и появляется он — PySpark, Python-интерфейс к Apache Spark. Apache Spark — это фреймворк для распределённой обработки больших данных. Он позволяет «переварить» десятки гигабайт данных на кластере из множества машин. Но не волнуйтесь: для начала достаточно даже локального режима — на одном компьютере. Что делает PySpark особенным? Во-первых, он поддерживает ленивое вычисление: операции с данными не выполняются немедленно, а накапливаются в виде плана выполнения. Это позволяет оптимизировать расчёты и сократить ненужные шаги. Во-вторых, PySpark масштабируется — запустите тот же код на одном ноутбуке или на сотне узлов Hadoop кластера, и всё сработает. Давайте посмотрим на реальные примеры. Прежде всего, установка: pip install pyspark Теперь минимальный пример создания DataFrame и работы с ним: from pyspark.sql import SparkSession from pyspark.sql.functions import avg # Инициализация Spark spark = SparkSession.builder.appName("BigDataAnalysis").getOrCreate() # Пример данных data = ("Alice", 25), ("Bob", 30), ("Charlie", 35), ("David", 40) columns = "name", "age" df = spark.createDataFrame(data, columns) # Простая трансформация dffiltered = df.filter(df.age > 30) dffiltered.show() Результат будет такой: +-------+---+ | name|age| +-------+---+ |Charlie| 35| | David| 40| +-------+---+ Теперь посчитаем средний возраст: dfavg = df.select(avg("age").alias("averageage")) dfavg.show() Вывод: +-----------+ |averageage| +-----------+ | 32.5| +-----------+ А ещё можно делать группировки, соединения, агрегации — примерно так же, как в pandas, но с учётом миллиардов строк. Особо стоит отметить PySpark SQL — возможность писать запросы прямо на SQL, обращаясь к таблицам, как к базам данных: df.createOrReplaceTempView("people") sqlresult = spark.sql("SELECT name FROM people WHERE age >= 30") sqlresult.show() Важно: всё это выполняется распределённо, если подключён кластер. Это значит, что даже при десятках гигабайт данных PySpark не утонет, в отличие от pandas. PySpark часто используется в реальных проектах: от анализа логов и телеметрии до обработки событий в режиме реального времени. В экосистеме — поддержка Kafka, Amazon S3, Hadoop HDFS, интеграция с MLlib (машинное обучение), GraphX (работа с графами) и другими мощными инструментами. Да, порог входа чуть выше, чем у pandas. Надо разобраться в концепциях RDD, DAG и планах выполнения, но результат того стоит. Начать можно локально, подключить ноутбук и Jupyter — и вперёд, к большим данным. PySpark — это не просто модуль, а целая философия обработки данных. Если вы чувствуете, что обычный инструментарий Python упирается в лимит — самое время попробовать Spark.

Современные инструменты для анализа больших данных на Python: модуль PySpark

Современные инструменты для анализа больших данных на Python: модуль PySpark

📄 Подписываем документы с Python: HelloSign API в действии В цифровом мире физические подписи — это как отправка писем с почты: можно, но зачем? Электронные подписи экономят время, автоматизируют бизнес-процессы и легитимны во многих странах. Сегодня разберём, как подключить HelloSign API с помощью Python и отправить документ на подпись за минуты. Что такое HelloSign? HelloSign — сервис электронных подписей, ныне часть Dropbox. Он позволяет отправлять документы на подпись, отслеживать статус, хранить подписанные версии и всё это через удобный API. Для разработчика это означает: не нужно городить свою инфраструктуру — просто вызывай метод. Начнём с подготовки Для работы понадобится: - Аккаунт на https://app.hellosign.com (бесплатный тестовый доступ есть) - API Key (доступен в настройках аккаунта) - Библиотека requests (если не установлена: pip install requests) Пример 1: Отправка документа на подпись Давайте отправим PDF-файл на подпись одному получателю. import requests apikey = "YOURAPIKEY" url = "https://api.hellosign.com/v3/signaturerequest/send" data = { "title": "NDA Agreement", "subject": "Please sign this NDA", "message": "Let me know if you have any questions.", "signers0email_address": "john@example.com", "signers0name": "John Doe", "signers0role": "Client", "testmode": "1" # 1 = тест, 0 = прод } files = { "file": open("ndatemplate.pdf", "rb") } response = requests.post(url, data=data, files=files, auth=(apikey, "")) print(response.json()) Если всё ок, в ответе будет ID запроса на подпись, статус и ссылка для отслеживания. Пример 2: Встраиваем форму в веб-приложение Можно встроить интерфейс HelloSign прямо в ваше приложение — клиент будет подписывать документ, не покидая сайт. Для этого используется embedded-подпись и фронтенд-библиотека (например, hellosign-embedded на JS), но бэкенд всё равно нужен: url = "https://api.hellosign.com/v3/signaturerequest/createembedded" data = { "clientid": "YOURCLIENTID", # получаем здесь: https://app.hellosign.com/apiapp "title": "Contract", "subject": "Please sign this contract", "message": "Contract for future collaboration.", "signers[0][emailaddress]": "alice@example.com", "signers0name": "Alice Smith", "signers0role": "Partner", "testmode": "1" } files = { "file": open("contract.pdf", "rb") } response = requests.post(url, data=data, files=files, auth=(apikey, "")) requestdata = response.json() signatureid = requestdata["signaturerequest"]"signatures"0"signature_id" # Получаем URL для встроенного окна подписи: embedurl = f"https://app.hellosign.com/editor/embeddedSign?signatureid={signatureid}" print("Embed URL:", embedurl) Теперь передаём embedurl на фронт, и пользователь видит форму подписи прямо на нашем сайте. Отслеживание подписей Удобно получать статус — документ подписан, отклонён, просрочен и т.д. statusurl = f"https://api.hellosign.com/v3/signaturerequest/{signatureid}" status = requests.get(statusurl, auth=(apikey, "")) print(status.json()) Для продвинутых задач можно настроить webhook — HelloSign будет сам уведомлять сервер о статусе. Плюсы использования HelloSign API: - Поддержка вложений, шаблонов и ролей - Уведомления, напоминания - Лёгкая интеграция - Embedded-подпись — удобно для UX - Подписи юридически валидны Минусы: - Бесплатный план ограничен - Требуется осторожность с персональными данными и соблюдение законодательства Заключение Интеграция HelloSign в Python-проект — не только просто, но и эффективно. За несколько строк кода вы получаете надёжный инструмент электронного документооборота. Работает стабильно, официальная документация понятна, а под капотом — готовый бизнес-инструмент с юридической основой.

Использование HelloSign API для обработки электронных подписей

🎙️ Как создать своего голосового помощника с использованием Python и SpeechRecognition Привет! Сегодня мы разберём, как создать простого голосового помощника на Python, который сможет воспринимать вашу речь и выполнять команды. И хотя до уровня Jarvis из «Железного человека» нам далеко, уже базовая реализация покажет вам, как работает распознавание речи, и даст в руки инструменты для дальнейших экспериментов. ⛏ Что понадобится: Из модулей нам понадобится: - speechrecognition — модуль для преобразования аудио в текст - pyaudio — для захвата звука с микрофона - pyttsx3 — чтобы помощник мог говорить в ответ - optionally: webbrowser или os для выполнения простых команд Установка (терминал):

pip install SpeechRecognition pyaudio pyttsx3

(если с pyaudio будут проблемы — скачайте колесо с https://www.lfd.uci.edu/~gohlke/pythonlibs/) 🚀 Первый голос: Начнём с простого — распознаем сказанную фразу и ответим на неё голосом. Пример кода:

import speech_recognition as sr
import pyttsx3

def speak(text):
    engine = pyttsx3.init()
    engine.say(text)
    engine.runAndWait()

def listen():
    recognizer = sr.Recognizer()
    with sr.Microphone() as source:
        print("I'm listening...")
        audio = recognizer.listen(source)
    try:
        return recognizer.recognize_google(audio)
    except sr.UnknownValueError:
        return "Sorry, I didn't catch that"
    except sr.RequestError:
        return "Service unavailable"

command = listen()
print("You said:", command)
speak("You said: " + command)

📌 Что тут происходит: - Микрофон слушает вас. - Речь преобразуется в текст через Google Speech API. - Программа озвучивает распознанную фразу. 🛠 Реакция на команды Теперь добавим простую обработку команд, чтобы наш голосовой помощник мог не только слушать, но и отвечать делом.

import webbrowser
import os

def handle_command(text):
    text = text.lower()
    if "open google" in text:
        webbrowser.open("https://www.google.com")
        return "Opening Google"
    elif "play music" in text:
        os.startfile("C:\\Users\\Public\\Music\\Sample Music\\song.mp3")
        return "Playing music"
    else:
        return "Command not recognized"

Слышим → Понимаем → Действуем:

command = listen()
response = handle_command(command)
speak(response)

🎯 Советы: - Используйте .lower() для обработки текста в нижнем регистре. - Можно подключить словари действий. - Расширьте помощника: пусть открывает почту, погоду, включает напоминания. ⚠ Важно: - Убедитесь, что микрофон работает. - Речь распознаётся через интернет (если используется Google API). - Для офлайн-распознавания обратите внимание на pocketsphinx (но качество будет хуже). 💡 Идеи на развитие: - Поддержка нескольких языков - Контекстный диалог - Интеграция с Telegram, Discord, голосовыми ассистентами - Связка с AI-моделями (например, ChatGPT через API) 🧠 Итог: С помощью всего пары библиотек мы создали основу для голосового помощника, способного понимать речь, реагировать на неё и выполнять действия. Настоящий ИИ начинается с простых шагов — а дальше всё ограничено только воображением и строчками кода. До встречи в следующем посте — скоро будем обучать ИИ распознавать эмоции по голосу! 🚀

Как создать своего голосового помощника с использованием Python и SpeechRecognition

Привет, друзья! Сегодня у нас по-настоящему магическая тема — предсказание будущего на Python. Да-да, мы поговорим о временных рядах и библиотеке Prophet от команды Facebook (теперь Meta). Prophet — это мощный инструмент для прогнозирования данных, зависящих от времени: будь то продажи, температура, количество посетителей сайта или биржевые котировки. Главное — данные со временем, а дальше Prophet делает чудеса. 📦 Установка и подготовка Начнем с установки библиотеки. Всё просто: pip install prophet (если используете Windows, не забудьте про компиляцию C++ зависимостей — возможно, поможет установка через conda). Для начала, импортируем необходимые библиотеки: import pandas as pd from prophet import Prophet import matplotlib.pyplot as plt 🕰️ Подготовка данных Prophet требует, чтобы таблица содержала два столбца: - ds — даты (datetime) - y — значения, которые мы хотим предсказывать Вот небольшой пример: data = pd.DataFrame({ 'ds': pd.daterange(start='2023-01-01', periods=100), 'y': [i + (i % 7)*5 for i in range(100)] # искусственный тренд с сезонностью }) Здесь мы сгенерировали искусственный временной ряд со слабым трендом и недельной сезонностью. 📈 Построение модели Создание модели — проще некуда: model = Prophet() model.fit(data) Prophet автоматически определит тренды, сезонности и управление выбросами. Не надо вручную настраивать параметры — хотя такая возможность есть. 🔮 Прогнозирование будущего Давайте предскажем следующие 30 дней: future = model.makefuturedataframe(periods=30) forecast = model.predict(future) Готово! В таблице forecast теперь есть не только прогноз (yhat), но и доверительные интервалы (yhatlower и yhatupper). 📊 Визуализация Самое приятное — красивые графики: model.plot(forecast) plt.title('Forecast by Prophet') plt.show() А если хотите понять поведение модели: model.plotcomponents(forecast) plt.show() Этот график покажет, какие сезонности найдены: годовая, недельная и тренд. 🎯 Особенности и тонкости - Prophet устойчив к пропущенным данным и выбросам. - Он автоматически обнаруживает праздничные дни, если передать список праздников. - Поддерживает настраиваемые сезонности: например, можно добавить месячную компоненту. model.addseasonality(name='monthly', period=30.5, fourierorder=5) - Управление праздниками: from prophet.serialize import modeltojson, modelfromjson # Модель можно сохранять и загружать без обучения заново. 🎓 Когда использовать Prophet? - У вас есть исторические временные данные (даты + значения). - Вы хотите предсказывать будущее без глубоких знаний в машинном обучении. - Нужна быстрая, но качественная модель “из коробки”. Prophet отлично работает с дневными, недельными и месячными рядами. Для часов и минут потребуется больше настройки. 📌 Заключение Prophet — это один из немногих инструментов, позволяющий буквально за пару строк кода создать работающий прогноз. Там, где требуется быстро получить MVP-модель или встроить предсказания в бизнес-приложение, Prophet — то, что нужно. Надеюсь, этот мини-гид помог вам увидеть, насколько мощным и удобным может быть прогнозирование со временными рядами. Увидимся в следующем посте!

Работа с временными рядами с использованием библиотеки Prophet

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

Название статьи: Как создать свой фреймворк на Python и не сойти с ума Создание собственного фреймворка на Python звучит внушительно — будто ты пишешь новое Django или Flask. Но если отбросить пафос, то это просто: ты создаёшь набор правил, структур и удобных инструментов, которые другие (или ты сам) смогут использовать для быстрой и понятной разработки. В этом посте разберёмся, как вообще подступиться к этой задаче, и какие техники стоит взять на вооружение. Главная цель фреймворка — абстрагировать рутину. Ты не хочешь каждый раз писать одну и ту же обработку запроса или логирование. Вместо этого ты хочешь сказать: “вот точка входа, вот контроллер, вот обработчик данных” — и всё заработало. Красиво? Красиво. Начинаем. 🔧 Архитектура: как кирпичи в доме Первый шаг — определить архитектурный скелет. MVC (Model-View-Controller), MVT (как у Django), функциональный стиль — неважно. Главное, чтобы ты чётко знал: где логика, где данные, где интерфейс. Минимальный фреймворк может выглядеть так: - точка входа: парсинг запроса, вызов контроллера; - роутер: определение, какая функция отвечает за запрос; - контроллер: логика обработки запроса; - шаблон или функция ответа. Пример: # simpleframework.py import re routes = {} def route(path): def decorator(func): routes[path] = func return func return decorator def application(env): path = env.get("PATH", "/") for pattern, handler in routes.items(): if re.fullmatch(pattern, path): return handler() return "404 Not Found" @route(r"/") def index(): return "Hello, World!" @route(r"/about") def about(): return "This is a demo framework." Здесь всё просто: у тебя есть декоратор @route, словарь маршрутов и функция application, которая решает, что выдать пользователю. ⚙️ Инверсия контроля: пусть фреймворк командует Одна из ключевых идей фреймворков — Inversion of Control. Это когда разработчик не вызывает функции фреймворка, а фреймворк сам вызывает код разработчика в нужное время. Ты предоставляешь “крючки” — функции, которые будут вызваны: обработчики маршрутов, middlewares, хуки при старте и завершении приложения. Когда ты пишешь: @route("/hello") def hello(): return "Hi!" ты лишь определяешь, что "фреймворк, если вдруг тебе попадается '/hello', вызови вот эту функцию". Это и есть инверсия управления. 🧪 Модули: используем stdlib по максимуму Хороший фреймворк использует стандартную библиотеку как фундамент. Вот пара модулей, которые сильно помогут: - inspect — позволяет анализировать аргументы функций, подсказывает, как их вызывать; - functools — особенно полезен for partial и wraps в декораторах; - collections — для гибких структур данных; - asyncio — если ты хочешь сделать асинхронный фреймворк. Например, добавим поддержку middleware-функций: middlewares = [] def use(middlewarefunc): middlewares.append(middlewarefunc) def application(env): path = env.get("PATH", "/") response = None for pattern, handler in routes.items(): if re.fullmatch(pattern, path): response = handler() break else: response = "404 Not Found" for middleware in reversed(middlewares): response = middleware(response) return response @use def uppercasemiddleware(resp): return resp.upper() Теперь любой ответ автоматически становится заглавным. Примитив? Зато гибкость и возможность масштабирования налицо. 📦 Упаковка: превращаем в установочный пакет Когда фреймворк готов, его стоит опубликовать. Используй setup.py, pyproject.toml и размещай проект на PyPI. Обрати внимание на структуру: myframework/ init.py core.py router.py ... docs/ tests/ Это не просто красота — это читаемость и поддерживаемость. Ни один разработчик не захочет копаться в мешанине файлов, даже если ты всё написал на гениальном Python. 🧠 Итого Создание фреймворка — это не магия, а аккуратная выжимка опыта.

Создание фреймворков на Python: основные подходы и техники