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

Изучение основ рефакторинга кода на Python для повышения его качества

# Изучение основ рефакторинга кода на Python для повышения его качества

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

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

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

## Почему стоит заниматься рефакторингом

Вот несколько причин, почему рефакторинг кода так важен:
1. Читаемость — Код, написанный с учетом лучших практик, будет понятен вам и другим разработчикам через месяц, год или даже спустя десятилетие.
2. Уменьшение технического долга — Каждый костыльный обходной путь или нелогичная конструкция увеличивает сложность поддержания проекта.
3. Легкость добавления новых функций — Чистый код проще адаптировать под изменения.
4. Предотвращение багов — Лаконичный и понятный код легче тестировать и отлаживать.

Теперь перейдем от теории к практике. Верх рефакторинга — это использование простых, но мощных подходов. Покажем несколько приемов.

---

### 1. Упрощение условий
Многословные конструкции if-elif-else могут быть реорганизованы, чтобы повысить их читаемость.

До рефакторинга:

def evaluate_score(score):
    if score >= 90:
        return "Excellent"
    elif score >= 75:
        return "Good"
    elif score >= 50:
        return "Average"
    else:
        return "Poor"

После рефакторинга:

def evaluate_score(score):
    if score >= 90: return "Excellent"
    if score >= 75: return "Good"
    if score >= 50: return "Average"
    return "Poor"

Простое удаление лишнего elif делает код более лаконичным и все равно сохраняет его логику.

---

### 2. Избавление от дублирования кода
Дублирование — враг разработчика. Оно приводит к путанице и увеличивает затраты на сопровождение.

До рефакторинга:

def calculate_area_rectangle(width, height):
    return width * height

def calculate_area_square(side):
    return side * side

После рефакторинга:

def calculate_area(shape, **dimensions):
    if shape == "rectangle":
        return dimensions['width'] * dimensions['height']
    if shape == "square":
        return dimensions['side'] ** 2

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

---

### 3. Разделение задач
Если функция начинает раздуваться до огромных размеров, это знак, что её пора разбить на более мелкие части.

До рефакторинга:

def process_user_data(data):
    for user in data:
        name = user["name"].capitalize()
        print(f"Processing user: {name}")
        user['id'] = generate_unique_id(user)
        save_user_to_db(user)

После рефакторинга:

def capitalize_name(name):
    return name.capitalize()

def process_user(user):
    user["name"] = capitalize_name(user["name"])
    user["id"] = generate_unique_id(user)
    save_user_to_db(user)

def process_user_data(data):
    for user in data:
        print(f"Processing user: {user['name']}")
        process_user(user)

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

---

### 4.

Использование встроенных функций и модулей Python
Иногда мы создаем решения «с нуля», даже когда Python предоставляет готовые инструменты.

До рефакторинга:

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

После рефакторинга:

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

Или, еще лучше:

squared = [x ** 2 for x in numbers]

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

---

### 5. Сделайте код самодокументируемым
Если ваши переменные, функции и классы названы понятно, кода без комментариев станет больше читаемым.

Плохое название:

def calc(a, b):
    return a / b

Хорошее название:

def calculate_ratio(numerator, denominator):
    return numerator / denominator

Называйте вещи своими именами, и вашему будущему «я» (как и коллегам) будет проще разобраться.

---

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

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

Обработка и анализ данных с использованием библиотеки xarray

💡 "Обработка и анализ данных с использованием библиотеки xarray"

Если вы когда-нибудь сталкивались с многомерными данными в формате NetCDF, HDF5 или Grib, то, скорее всего, вам не раз приходилось морщиться, разбираясь в массивах, индексах и измерениях. NumPy — мощный инструмент, но когда дело доходит до обработки реальных научных данных с координатами, метаданными и измерениями вроде времени, высоты, широты и долготы, руки сразу тянутся за чем-то более удобным. Знакомьтесь, xarray — библиотека, созданная словно специально для этого случая.

Xarray — это библиотека для работы с многомерными метками массивов. По своей сути, она расширяет возможности NumPy-ndarray, добавляя к ним координаты, имена измерений и удобную навигацию по данным. Она вдохновлена архитектурой pandas, но ориентируется на данные с большим количеством измерений: климатические модели, спутниковые наблюдения, сложные временные ряды и многое другое.

Основные структуры данных — это DataArray и Dataset.

🧩 DataArray — это аналог Series или одного массива NumPy, но с координатами и метаинформацией.
📦 Dataset — это коллекция связанных DataArray, грубо говоря — как DataFrame в pandas, но для многомерных данных.

Рассмотрим на примере:

import xarray as xr
import numpy as np

times = np.arange('2022-01', '2022-04', dtype='datetime64M')
locations = 'Moscow', 'London', 'New York'

data = xr.DataArray(
np.random.rand(3, 3),
coords={'time': times, 'city': locations},
dims='time', 'city'
)

print(data)

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

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

meantemp = data.mean(dim='time')
print(meantemp)

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

maxtemp = data.idxmax(dim='time')
print(maxtemp)

Что особенно приятно — xarray понимает работу с временем, может агрегировать по периодам, объединять различные источники данных, строить маски и проводить интерполяции.

Подробнее — загрузка из NetCDF:

ds = xr.opendataset('airtemperature.nc')
print(ds)

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

ds.sel(time='2022-01-15', method='nearest')
ds'air'.mean(dim='lat', 'lon').plot()

И, конечно, совместимость с pandas и NumPy — бесшовная. DataArray легко превращается в DataFrame при необходимости:

df = data.todataframe().resetindex()
print(df.head())

Xarray активно используется в метеорологии, океанологии и науках о Земле, но он может пригодиться и в работе с машинным обучением, и просто с временными рядами. Если ваши данные превышают два измерения — забудьте про громоздкие NumPy-аксессоры. Xarray — это ваш новый лучший друг.

✨ Итоги:

- Удобная работа с многомерными данными с именованными координатами.
- Поддержка времени и стандарта CF (важно для научных данных).
- Отличная интеграция с dask (для "ленивой" параллельной обработки).
- Поддержка чтения и записи современных форматов: NetCDF, Zarr, HDF5.

Если в pandas вы чувствовали себя Шерлоком, то в xarray вы — уже профессор в Лондоне с доступом к спутниковым данным. Попробуйте — и удивитесь, насколько сложные штуки можно делать просто, прозрачно и pythonic.

Введение в работу с протоколом WebRTC на Python

Привет! Сегодня поговорим о технологии, которая лежит в основе видеозвонков, конференц-связи и P2P-коммуникаций в браузере — о WebRTC. Но не спеши закрывать вкладку: мы разберёмся, как управлять этим «веб-монстром» с помощью Python. Да, ты не ослышался — WebRTC и Python вполне могут подружиться!

Что такое WebRTC?

WebRTC (Web Real-Time Communication) — это открытый протокол и набор API, позволяющих браузерам, мобильным и десктопным приложениям обмениваться аудио, видео и данными в реальном времени без необходимости в сторонних плагинах. Всё безопасно, peer-to-peer и максимально быстро.

Python сам по себе не может напрямую управлять WebRTC-соединениями в браузере (всё-таки WebRTC — это технология клиентская), но есть замечательная библиотека, которая позволяет Python участвовать в процессе как полноценному участнику медиасессий. Встречайте: aiortc!

aiortc — это чистая реализация WebRTC и ORTC на Python с поддержкой asyncio. С её помощью можно написать своего собственного WebRTC-пира, сервер для видеочатов, обработчик видео из браузера и многое другое.

Что умеет aiortc:

- Принимать и отправлять аудио/видео
- Работать с data channel’ами
- Поддерживает SDP, ICE и STUN
- Совместим с браузерами вроде Chrome и Firefox

Минимальный пример: обмен видеопотоком между браузером и Python-сервером

Установим:

pip install aiortc opencv-python

Теперь пишем Python-сервер, который получает видео с браузера и отображает (или записывает) его через OpenCV:

from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
import cv2
import asyncio
import json
from aiohttp import web

pc = RTCPeerConnection()

@pc.on("track")
def ontrack(track):
if track.kind == "video":
@track.on("frame")
async def onframe(frame):
img = frame.tondarray(format="bgr24")
cv2.imshow("Received Video", img)
cv2.waitKey(1)

async def offer(request):
params = await request.json()
offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
await pc.setRemoteDescription(offer)
answer = await pc.createAnswer()
await pc.setLocalDescription(answer)

return web.Response(
contenttype="application/json",
text=json.dumps(
{"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}
),
)

app = web.Application()
app.router.addpost("/offer", offer)

web.runapp(app, port=8080)

На стороне браузера можно использовать стандартный WebRTC API для отправки видео (обычно через getUserMedia, RTCPeerConnection и fetch).

Что важно: aiortc — это не сервер-сигнализации. Он не занимается организацией "встреч" между пользователями. Этим должен заниматься отдельный механизм — WebSocket или HTTP обмен сообщениями (как в примере выше).

Зачем нужен Python в WebRTC?

- Обработка видео в реальном времени (например, нейросетями)
- Получение видеопотока от клиента и передача его другому клиенту
- Логирование, хранение или трансляция через другие каналы
- Строительство полной медиа-платформы

Тем, кто работает с системами видеонаблюдения, ML/AI в потоковом видео или хочет написать Telegram-бота, принимающего живое видео с браузера, aiortc открывает массу возможностей.

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

В следующей статье — сделаем свой минимальный видеочат с Python и WebRTC. А пока — экспериментируй!

Основы работы с нейронными сетями и их развертывания с ONNX

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

Что такое нейронная сеть?

Грубо говоря, нейронная сеть — это алгоритм, вдохновлённый работой мозга. Она получает входные данные, обрабатывает их через слои искусственных нейронов и выдаёт результат. Например, можно скормить ей изображение кошки, и она скажет: "Это кошка". Главное — сначала научить её это делать.

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

pip install torch torchvision onnx onnxruntime

Допустим, у нас есть модель, распознающая рукописные цифры (как в MNIST). Пример:

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleNet(nn.Module):
def init(self):
super(SimpleNet, self).init()
self.fc1 = nn.Linear(28 28, 128)
self.fc2 = nn.Linear(128, 10)

def forward(self, x):
x = x.view(-1, 28 28)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x

model = SimpleNet()
dummyinput = torch.randn(1, 1, 28, 28)

Теперь самое интересное — экспорт модели в формат ONNX:

torch.onnx.export(
model,
dummyinput,
"simplenet.onnx",
inputnames=['input'],
outputnames='output',
dynamicaxes={'input': {0: 'batchsize'}, 'output': {0: 'batchsize'}},
opsetversion=11
)

Файл simplenet.onnx теперь можно загружать практически куда угодно: в C++, в браузер через WebAssembly, или, скажем, в мобильное приложение.

А как запустить модель ONNX? Используем библиотеку onnxruntime:

import onnxruntime as ort
import numpy as np

session = ort.InferenceSession("simplenet.onnx")
inputdata = np.random.rand(1, 1, 28, 28).astype(np.float32)
preds = session.run(None, {"input": inputdata})
print("Prediction:", np.argmax(preds0))

Вуаля — мы запустили нейросеть без PyTorch! Быстро, кроссплатформенно и с минимальными зависимостями.

Зачем нужен ONNX?

- Универсальность: перенос обученной модели между фреймворками (PyTorch → TensorFlow, например).
- Лёгкость развёртывания: можно запускать модели на сервере, в мобильных или web-приложениях.
- Оптимизация: многие среды умеют оптимизировать ONNX-модели — например, ускорять инференс на CPU или GPU.

Советы напоследок

- Следите за версией opset при экспорте — разные движки могут поддерживать разные спецификации.
- Если модель не экспортируется напрямую, сначала упростите архитектуру или проверьте поддержку нестандартных слоёв.
- ONNX можно визуализировать через Netron (https://netron.app/) — отличный инструмент для отладки моделей.

ONNX — это как USB для нейросетей: подключай куда угодно. Если вы работаете с нейросетями и хотите, чтобы модели были лёгкими в использовании и развёртывании, обязательно добавьте ONNX в свой инструментарий.

До встречи в следующих постах!

Как написать HTTP сервер с использованием модуля http.server

Привет, друзья! Сегодня мы нырнём в удивительно простой, но мощный модуль стандартной библиотеки Python — http.server. С его помощью можно всего в несколько строк кода поднять настоящий HTTP-сервер. Без сторонних зависимостей, фреймворков или танцев с бубном.

Зачем это нужно? Например, для локальной отладки веб-приложений, быстрой раздачи файлов с вашей машины, тестирования API или даже написания простейшего backend'а. Итак, приступим!

Минимальный HTTP-сервер за 10 секунд

Внимание, магия! Вот базовый пример:

from http.server import SimpleHTTPRequestHandler, HTTPServer

server_address = ('', 8000)
httpd = HTTPServer(server_address, SimpleHTTPRequestHandler)
print("Server running on http://localhost:8000")
httpd.serve_forever()

Сохрани файл как simpleserver.py, запусти, и зайди в браузере на http://localhost:8000. Ты увидишь содержимое текущей директории — по сути, это файловый сервер “из коробки”.

Обратите внимание:

- Пустая строка в serveraddress означает, что сервер слушает все IP адреса.
- Port 8000 — дефолтный, можно выбрать любой другой.

А что если захотим свой ответ, а не просто отдавать файлы?

Создадим собственный обработчик:

from http.server import BaseHTTPRequestHandler, HTTPServer

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-Type', 'text/html')
        self.end_headers()
        message = "<h1>Hello, Python HTTP Server!</h1>"
        self.wfile.write(message.encode('utf-8'))

server_address = ('', 8080)
httpd = HTTPServer(server_address, MyHandler)
print("Custom server running on http://localhost:8080")
httpd.serve_forever()

Теперь при любом GET-запросе сервер вернёт простую HTML-страничку. Всё управляется методом doGET. Можно переопределить и другие: doPOST, doPUT, doDELETE.

Парсим путь и параметры

Допустим, мы хотим разные ответы в зависимости от URL. Используем модуль urllib:

from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        parsed_url = urlparse(self.path)
        path = parsed_url.path
        query = parse_qs(parsed_url.query)

        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()

        if path == '/hello':
            name = query.get('name', ['stranger'])[0]
            response = f"Hello, {name}!"
        else:
            response = "Unknown path."

        self.wfile.write(response.encode('utf-8'))

server_address = ('', 9000)
httpd = HTTPServer(server_address, MyHandler)
print("Query-enabled server running on http://localhost:9000")
httpd.serve_forever()

Попробуйте перейти на http://localhost:9000/hello?name=Alice — сервер ответит: Hello, Alice!

Нюансы и ограничения

- http.server идеально подходит для простых задач, но не заменит полноценный фреймворк вроде Flask или FastAPI.
- Он однопоточный — один запрос за раз. Не подходит для продакшена.
- Без HTTPS — только HTTP.

Зато:

- Не требует установки — есть в любом Python.
- Отличен для отладки, обучения и мини-экспериментов.

Вывод

http.server — как швейцарский нож для любого Python-разработчика. Минимум кода — максимум пользы. Иногда лучшая магия — это простота.

До встречи в следующем посте!

Работа с генетическими алгоритмами в Python: библиотека DEAP

Привет! Сегодня поговорим о теме, которая звучит так, будто была взята из научной фантастики, но на деле имеет массу практического применения — генетические алгоритмы. Если ты когда-нибудь задумывался, как можно применять принципы естественного отбора для решения задач оптимизации — читай дальше. Мы познакомимся с удивительной библиотекой DEAP (Distributed Evolutionary Algorithms in Python), которая делает работу с эволюционными алгоритмами на Python простой и вдохновляющей.

Зачем вообще нужны генетические алгоритмы? Представь, что тебе нужно найти оптимальное решение в огромном пространстве возможных вариантов — классический перебор займёт вечность. Генетические алгоритмы работают по-другому: они "эволюционируют" популяцию решений, отбирая лучших "индивидов", скрещивая их и мутируя. Этот подход широко используется в инженерии, дизайне нейросетей, игровой индустрии и даже в экономике.

Теперь к практике. Устанавливаем DEAP:

pip install deap

Допустим, мы хотим найти максимум функции:

f(x) = x sin(x), где x от 0 до 10

Вот пример минимального рабочего кода на DEAP:

from deap import base, creator, tools, algorithms
import random
import math

# Создаем типы для нашей задачи
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

toolbox = base.Toolbox()

# Гене — это просто одно число
toolbox.register("attr_float", random.uniform, 0, 10)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, 1)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

# Целевая функция
def evaluate(individual):
x = individual[0]
return x math.sin(x),

toolbox.register("evaluate", evaluate)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)

# Запуск эволюции
def run():
population = toolbox.population(n=50)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("max", max)
stats.register("avg", lambda x: sum(x)/len(x))

population, log = algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=40, stats=stats, verbose=False)

best = tools.selBest(population, 1)0
print(f"Best individual: x = {best0:.3f}, f(x) = {evaluate(best)0:.3f}")

run()

Что здесь происходит:
- Мы создаем индивидуумов — списки, содержащие одно число (значение x).
- Определяем функцию приспособленности evaluate.
- Используем стандартные операторы скрещивания (cxBlend) и мутации (mutGaussian).
- Запускаем эволюцию и находим наилучшее решение после 40 поколений.

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

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

До встречи в следующем посте!

Как создавать среду для скрининга на вирусы с Python и ClamAV

Заголовок: Защищаем файлы Python'ом: антивирусная среда с ClamAV

Привет! Сегодня мы рассмотрим, как создать простую, но эффективную среду на Python для скрининга файлов на вирусы — руками программиста, используя бесплатный антивирус ClamAV.

Зачем это нужно? Представим: ты разрабатываешь веб-приложение с загрузкой файлов от пользователей. Кто-то может попытаться загрузить вредоносный .exe или .zip-сюрприз. Чтобы не запускать бомбу в своей системе — нужно проверять эти файлы заранее.

Здесь на помощь приходит ClamAV — легкий, кроссплатформенный антивирус с поддержкой командной строки. А Python позволяет автоматизировать и вшить проверку в любое приложение.

🔧 Установка ClamAV

На большинстве Linux-систем установка простая:

sudo apt update
sudo apt install clamav clamav-daemon

Для обновления вирусных баз:

sudo freshclam

Если ты на Windows — скачай инсталлятор с сайта проекта (https://www.clamav.net/) и добавь путь до clamscan в системные переменные.

🐍 Работаем из Python

Чтобы взаимодействовать с ClamAV из Python, можно использовать модуль subprocess для запуска процесса сканирования через clamscan, а также библиотеку pyclamd, если хочешь использовать daemon-режим.

Рассмотрим сначала с subprocess:

import subprocess

def scanfile(filepath):
result = subprocess.run("clamscan", file_path, stdout=subprocess.PIPE, text=True)
output = result.stdout
if "OK" in output:
return "Clean"
elif "FOUND" in output:
return "Infected"
else:
return "Unknown"

print(scanfile("sample.zip"))

Этот код запускает сканирование и парсит результат. Если в выводе встречается “FOUND” — пора бить тревогу.

Теперь подход с pyclamd — более быстрый, если у тебя запущен демон ClamAV (clamd):

pip install pyclamd

import pyclamd

def scanwithdaemon(filepath):
cd = pyclamd.ClamdUnixSocket()
if not cd.ping():
raise ConnectionError("ClamAV daemon is not running.")
result = cd.scanfile(filepath)
if result is None:
return "Clean"
else:
return "Infected"

print(scanwithdaemon("test.pdf"))

🚀 Как использовать

Ты можешь встроить этот сканер в Django или Flask-приложение, настроить папку мониторинга (например, сканируем все, что появляется в uploads/) или устроить cron-задачу по расписанию.

🗂 Нюансы

- ClamAV не проверяет содержимое архивов “глубоко”, если не установлен параметр --recursive или в clamd.conf не включён ScanArchive.
- Производительность: clamd быстрее clamscan, потому что один раз загружает сигнатуры.
- Без обновлений баз смысла нет — freshclam должен запускаться регулярно.

📦 Бонус: сканирование всей директории

def scandirectory(path):
result = subprocess.run(["clamscan", "-r", path], stdout=subprocess.PIPE, text=True)
infections = [line for line in result.stdout.split("\n") if "FOUND" in line]
return infections

infections = scandirectory("/home/user/uploads")
for item in infections:
print(item)

🔐 Итого:

- ClamAV + Python — это реальный способ добавить сканирование на вирусы.
- Можно быстро защитить backend загрузки файлов.
- Используем subprocess или pyclamd, в зависимости от потребностей.

Превратить Python-приложение в антивирусную мини-систему — проще, чем кажется. Рекомендую попробовать на практике — лучше один раз построить, чем сто раз удалить троян.

https://t.me/info_sol

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

Реализация базовых шифров с библиотекой Cryptography

🔐 Реализация базовых шифров с библиотекой Cryptography в Python

Шифрование — одна из тех тем, которые звучат как нечто мистическое для новичков. Но на деле, благодаря библиотеке cryptography, реализовать базовые методы шифрования в Python проще, чем испечь бутерброд. Сегодня разберём два практических варианта: симметричное и асимметричное шифрование.

Начнём с установки:

pip install cryptography

Готово? Погружаемся.

🔥 Симметричное шифрование с Fernet

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

Модуль Fernet из cryptography делает весь процесс элементарным:

from cryptography.fernet import Fernet

# Генерация ключа
key = Fernet.generatekey()
cipher = Fernet(key)

# Шифруем текст
originaltext = b'This is a secret message.'
encryptedtext = cipher.encrypt(originaltext)

# Дешифруем
decryptedtext = cipher.decrypt(encryptedtext)

print('Encrypted:', encryptedtext)
print('Decrypted:', decryptedtext.decode())

Жутко просто, не правда ли? Ключ здесь — это случайная строка байтов (44 символа в base64), и если потеряете — расшифровать будет уже нельзя. Ровно как и задумано.

🔐 Асимметричное шифрование с RSA

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

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

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes

# Генерация пары ключей
privatekey = rsa.generateprivatekey(publicexponent=65537, keysize=2048)
publickey = privatekey.publickey()

# Шифруем с помощью публичного ключа
message = b'RSA encryption example.'
encrypted = publickey.encrypt(
message,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(), label=None)
)

# Расшифровываем с помощью приватного ключа
decrypted = privatekey.decrypt(
encrypted,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(), label=None)
)

print('Encrypted (RSA):', encrypted)
print('Decrypted (RSA):', decrypted.decode())

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

💡 Важные моменты

- Библиотека cryptography использует низкоуровневые привязки OpenSSL, поэтому она не только удобна, но и достаточно надёжна.
- RSA шифрует только короткие сообщения. Для реальной передачи больших данных обычно шифруют симметричным ключом, а его уже шифруют RSA.
- Ни Fernet, ни RSA не гарантируют анонимность или защиту от всех атак — это всего лишь строительные блоки.

📦 Вывод

Хотя на первый взгляд шифрование может показаться чем-то пугающим, с cryptography ты получаешь мощный инструмент, который легко применять даже на ранней стадии изучения Python. И пусть это только основа, зато какая прочная!

Чтение и обработка CSV-файлов с помощью модуля csv: примеры и лучшие практики