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

Привет! Сегодня погрузимся в магию работы с текстами на Python и разберём сразу два популярных инструмента для обработки естественного языка — NLTK и spaCy. Даже если вы только начали путь питониста, с этими библиотеками вы сможете анализировать тексты, искать ключевые слова, определять части речи и делать ещё массу интересного. ### NLTK — классика жанра NLTK (Natural Language Toolkit) часто называют «швейцарским ножом» для языкового анализа. Несмотря на почтенный возраст, NLTK актуален благодаря богатейшему набору функций и огромному количеству встроенных корпусов (наборов текстов для анализа). Разберём простой пример — разбор текста на предложения и слова:

import nltk
nltk.download('punkt')

text = "Python is great. Natural Language Processing is fascinating!"
sentences = nltk.sent_tokenize(text)
words = [nltk.word_tokenize(sentence) for sentence in sentences]
print(sentences)
print(words)

NLTK также умеет определять части речи:

nltk.download('averaged_perceptron_tagger')

tokens = nltk.word_tokenize("SpaCy is faster than NLTK in many tasks.")
pos_tags = nltk.pos_tag(tokens)
print(pos_tags)

### spaCy — быстрый и современный Если вам нужен максимально быстрый и удобный инструмент — берите spaCy. Он из коробки умеет извлекать сущности, токенизировать текст, разбивать слова по частям речи и много чего ещё, причём делает это молниеносно. Пример выделения именованных сущностей (людей, компаний, городов):

import spacy

nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple is looking at buying U.K. startup for $1 billion")
for ent in doc.ents:
    print(ent.text, ent.label_)

Ещё spaCy великолепно разбирается с лемматизацией (приведение слова к базовой форме):

for token in doc:
    print(token.text, token.lemma_)

### Что выбрать? NLTK — хороший выбор для обучения, экспериментов и когда нужен гибкий доступ к лингвистическим инструментам. spaCy — чемпион по скорости и простоте для реальных приложений. К тому же их можно комбинировать: например, токенизацию делать в spaCy, а сложную работу с корпусами доверить NLTK. С текстами в Python можно творить чудеса, и знакомство с этими библиотеками — отличное начало. Удачной практики! — Иван

- Использование библиотек для обработки естественной речи: nltk и spaCy

Привет! На связи Иван, и сегодня разберём одну из самых интересных фишек современного Python — асинхронное программирование с помощью модуля asyncio. Если тебе надоело ждать, пока твой скрипт скачает десяток страниц одну за другой, значит, самое время освоить новый подход! ## Почему именно asyncio? Обычные (синхронные) функции скачивают данные поочерёдно: началась загрузка — жди, пока закончится. А вот с asyncio мы можем делать несколько запросов одновременно, не блокируя выполнение программы! Это особенно круто, когда надо работать с большим количеством сетевых ресурсов. ## Первый шаг: Корутинa и event loop Всё строится вокруг корутин (функций с async def) и главного цикла событий — event loop. Вот как можно скачать сразу несколько страниц (например, с помощью aiohttp):

import asyncio
import aiohttp

async def fetch_page(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        "https://example.com",
        "https://httpbin.org/get",
        "https://python.org"
    ]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_page(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for i, html in enumerate(results):
            print(f"Page {i+1} downloaded, length: {len(html)}")

asyncio.run(main())

## Разбираем пример: - async def fetch_page — корутина, которая асинхронно скачивает страницу. - session.get(url) внутри асинхронного контекста. Нет блокировки на сеть! - asyncio.gather(*tasks) — запускает сразу несколько загрузок; программа ждёт, когда все завершатся. - Результаты появляются, когда всё скачалось. ## Ещё парочка лайфхаков 1. IO-операции (HTTP-запросы, чтение файлов) лучше всего подходят для асинхронного подхода. 2. Используй aiohttp или другие async-библиотеки — работать с обычным requests тут нельзя. 3. Не забывай про async with — он гарантирует правильное закрытие соединения. Вот так, всего пара строк — и твой Python-код работает в разы быстрее там, где раньше скучал, глядя на загрузку одного URL за другим! Попробуй — и почувствуй разницу. До встречи, Иван.

- Основы работы с модулем asyncio для загрузки сетевых данных

Привет! С вами Иван, и сегодня мы разберём тему, которой часто пренебрегают новички: качество оформления кода. Возможно, вы слышали о загадочном PEP8 и модуле black, но пока не решались познакомиться поближе? Тогда устраивайтесь поудобнее — сейчас разберём всё на пальцах. ## Что такое PEP8? PEP8 — это официальный стиль написания кода на Python. Или, проще говоря, набор рекомендаций, как писать код понятно не только себе, но и другим. Вот некоторые ключевые моменты: - отступы: только 4 пробела; - длина строк: лучше укладываться в 79 символов; - имена переменных: snake_case, никаких camelCase; - между функциями — две пустых строки, между методами — одна. Пример «неправильного» кода:

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

И вот так — по PEP8:

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

Лаконично, читаемо — и глаз радуется. ## Форматируем код автоматически: знакомство с black В мире, где приходится работать с десятками файлов, перебирать пробелы вручную — путь для мазохистов. Здесь на сцену выходит black — грозный (и очень полезный) автоформаттер кода. ### Установка Black ставится одной командой:

pip install black

### Использование Форматируем файлы или целые проекты:

black my_script.py

Black сам поправит отступы, длину строк, расставит пробелы. Причём форматирование очень строгое: порядка больше, споров меньше! Вот пример до и после:

def fibonacci(n): a, b = 0, 1; result = [] 
for _ in range(n): result.append(a); a, b = b, a+b
return result

после команды black:

def fibonacci(n):
    a, b = 0, 1
    result = []
    for _ in range(n):
        result.append(a)
        a, b = b, a + b
    return result

## Почему это важно? Чистый код читается легче, поддерживается быстрее, и экономит время вашей команды. Придерживаясь PEP8 и используя инструменты вроде black, вы быстро привьёте себе привычку писать не только рабочий, но и красивый Python-код. На сегодня всё, до встречи в новых постах!

- Работа с PEP8 и форматирование кода с помощью black

Привет! Меня зовут Иван, и сегодня мы разберём, как создать распределённое приложение на Python с помощью ZeroMQ — одного из самых мощных инструментов для обмена сообщениями между процессами и машинами. Что такое ZeroMQ? Если коротко: это библиотека, которая позволяет писать приложение, способное «разговаривать» с другими частями системы через сеть или на одном компьютере, не заморачиваясь низкоуровневой реализацией протоколов и сокетов. Всё просто и надёжно. Почему стоит попробовать ZeroMQ? - Поддержка разных топологий: «точка-точка», паблиш/сабскрайб, очередь задач. - Лёгкость внедрения — всё работает через обычные TCP/IPC-соединения, и не требует сервера-брокера. - Производительность и масштабируемость. Пример 1. Простое распределённое приложение: сервер-задачник и работник server.py:

import zmq

context = zmq.Context()
socket = context.socket(zmq.PUSH)
socket.bind("tcp://127.0.0.1:5557")

for i in range(10):
    msg = f"Task #{i}"
    print(f"Send: {msg}")
    socket.send_string(msg)

worker.py:

import zmq
import time

context = zmq.Context()
socket = context.socket(zmq.PULL)
socket.connect("tcp://127.0.0.1:5557")

while True:
    msg = socket.recv_string()
    print(f"Received: {msg}")
    time.sleep(1)

Добавьте несколько worker.py — увидите, как задачи будут распределяться между ними. Так просто вы получите базовую очередь задач! Пример 2. Публикация и подписка (Pub/Sub) publisher.py:

import zmq
import time

context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://127.0.0.1:5556")

while True:
    socket.send_string("news Hello subscribers!")
    time.sleep(1)

subscriber.py:

import zmq

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://127.0.0.1:5556")
socket.setsockopt_string(zmq.SUBSCRIBE, "news")

while True:
    msg = socket.recv_string()
    print(f"Got: {msg}")

Итоги ZeroMQ — отличный способ познакомиться с реальным распределённым программированием. Он прост в изучении, эффективен и позволяет строить масштабируемые приложения практически без лишней сложности. Берите эти примеры за основу — и экспериментируйте!

- Как создать распределенное приложение с использованием ZeroMQ

Привет! С вами Иван, и сегодня мы нырнем в мир производительного Python с помощью замечательного инструмента — locust. Если вы когда-нибудь задумывались, как проверить, справится ли ваш сайт или приложение с наплывом пользователей, locust — это именно то, что вам нужно. Что такое locust? Locust — это простой, но мощный фреймворк для тестирования производительности. Он позволяет описывать сценарии нагрузки на Python и смотреть, как система ведёт себя под реальной «атакой» пользователей. Приятный бонус: вы управляете тестами через web-интерфейс, а все сценарии пишете привычным вам питоном. Установка Поставить locust — проще простого:

pip install locust

Создаём первый тест Напишем небольшой пример. Допустим, у нас есть API, и мы хотим проверить, как оно выдержит поток запросов.

from locust import HttpUser, TaskSet, task, between

class SimpleTasks(TaskSet):
    @task
    def get_root(self):
        self.client.get("/")

class WebsiteUser(HttpUser):
    tasks = [SimpleTasks]
    wait_time = between(1, 3)

В этом примере мы определили пользователя (WebsiteUser), который каждую 1-3 секунды отправляет запрос на главную страницу (/). В классе SimpleTasks можно описывать разные действия, которые пользователь будет выполнять. Запускаем нагрузку В терминале переходим в папку с вашим скриптом и пишем:

locust -f my_locust_file.py --host http://example.com

Переходим по адресу http://localhost:8089 — и перед вами удобный web-интерфейс для запуска нагрузки. Почему это круто? - Сценарии на Python, а не на странных DSL; - Реальное моделирование пользователей, а не бездушные потоки запросов; - Детализированная статистика и красивые графики. Ваша первая миссия Попробуйте построить свой сценарий на locust, добавить несколько разных запросов, может быть, даже авторизацию. Почувствуйте себя настоящим «нагрузчиком» и узнайте, где болит ваш код! На этом всё, до новых тестов!

- Введение в тестирование производительности с locust

Привет, друзья! Сегодня я, Иван, расскажу, как легко и быстро создавать эмбеддинги текста с помощью двух отличных Python-модулей — modulos-embed и gensim. Если вы всегда хотели «запихивать» смысл предложений в числа, этот пост — для вас! ## Для начала: зачем эмбеддинги? Эмбеддинги — это способ представить текст в виде векторов фиксированной длины, чтобы машины могли «понимать» его с помощью математики. С помощью эмбеддингов алгоритмы машинного обучения становятся ближе к понимаю человеческого языка: вы можете искать схожие тексты, кластеризовать документы, и даже строить рекомендательные системы. ## Быстрый старт с modulos-embed Модуль modulos-embed умеет превращать тексты в эмбеддинги буквально в одну строчку. Для этого не нужно глубоких знаний в NLP или заставлять компьютер часами обучать модели. Установка:

pip install modulos-embed

Пример преобразования:

from modulos.embed import EmbedClient

client = EmbedClient()
texts = ["I love Python.", "Python is a versatile programming language."]
embeddings = client.embed(texts)
print(embeddings.shape)  # (2, 512)

Каждое предложение теперь — строка из 512 чисел. Модуль, кстати, поддерживает несколько языков! ## Создаём эмбеддинги с gensim gensim — старый добрый пакет для тематических моделей и обучения векторных представлений, например, Word2Vec. Установка:

pip install gensim

Пример использования Word2Vec:

from gensim.models import Word2Vec

sentences = [
    ["python", "is", "great"],
    ["i", "love", "coding", "in", "python"]
]
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=2)
vector = model.wv["python"]
print(vector[:10])  # Показано первые 10 значений вектора

Здесь каждая отдельная «python» превращается в свой 100-мерный вектор. Вы можете брать такие вектора для слов и усреднять их для целых фраз и документов. ## Кратко о главном - modulos-embed: для быстрых и простых эмбеддингов целых фраз и документов, одной строчкой, с предобученной моделью. - gensim: гибко и удобно — хорошо подходит для экспериментов с отдельными словами и кастомизацией обучения. Попробуйте оба инструмента и выберите тот, который лучше подойдёт под вашу задачу!

- Создание эмбеддингов для текста с modulos embeed и gensim

Привет! На связи Иван, и сегодня я расскажу, как сделать формы Django не только красивыми, но и отзывчивыми с помощью Django Crispy Forms. Если ты когда-либо создавал формы в Django, то знаешь, какими унылыми они выглядят по умолчанию. А хочется ведь, чтобы всё было “вау”! Вот тут и приходит на помощь “хрустящий” модуль. Что такое Django Crispy Forms? Crispy Forms — сверхполезное расширение для Django, чтобы быстро (и, главное, легко) внедрять адаптивные и красивые формы. Оно отлично дружит с Bootstrap — популярнейшим CSS-фреймворком для отзывчивого дизайна. Установка Сначала, конечно, устанавливаем сам crispyforms и Bootstrap, если его ещё нет: ```bash pip install django-crispy-forms pip install crispy-bootstrap5 # последняя версия Bootstrap ``` Затем добавляем в `settings.py`: ```python INSTALLEDAPPS = ... "crispy_forms", "crispy_bootstrap5", CRISPYALLOWEDTEMPLATEPACKS = "bootstrap5" CRISPYTEMPLATEPACK = "bootstrap5" ``` **Использование: магия в действии** Стандартная форма в Django: ```python from django import forms class ContactForm(forms.Form): name = forms.CharField(maxlength=100) email = forms.EmailField() message = forms.CharField(widget=forms.Textarea)

Чтобы сделать её «хрустящей» и отзывчивой, используем Crispy Forms в шаблоне:

django {% load crispyformstags %} <form method="post"> {% csrftoken %} {{ form|crispy }} <button type="submit" class="btn btn-primary">Send</button> </form> ``` Благодаря фильтру `crispy`, поля автоматически получают классы Bootstrap, а сама форма становится адаптивной! **Совет:** чтобы кастомизировать расположение полей или добавить дополнительные визуальные элементы, воспользуйся Layout из crispyforms:

from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Row, Column, Submit

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100)
    email = forms.EmailField()
    message = forms.CharField(widget=forms.Textarea)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Row(
                Column('name', css_class='form-group col-md-6 mb-0'),
                Column('email', css_class='form-group col-md-6 mb-0'),
                css_class='form-row'
            ),
            'message',
            Submit('submit', 'Send')
        )

Теперь форма распределяется по двум колонкам на широкой странице — динамично и удобно для пользователя! Вывод Django Crispy Forms — идеальный напарник для тех, кто хочет не тратить нервы на верстку форм, но при этом делать их стильными и отзывчивыми. А главное — процесс кастомизации максимально гибок и интуитивен, даже если ты только начинаешь изучать Django. До встречи в следующей статье!

- Как внедрить отзывчивый дизайн в Django с использованием Django Crispy Forms

- Как внедрить отзывчивый дизайн в Django с использованием Django Crispy Forms

Привет, друзья! Меня зовут Иван, и сегодня я расскажу о библиотеке, которая превратит ваш Python-скрипт в детектор QR-кодов — встречайте, zbar! Зачем вообще обрабатывать QR-коды в Python? Казалось бы, приложения на смартфоне всё делают за нас. Но представьте: у вас огромная база изображений, где зашифрованы купоны, анкеты, ключи доступа… Не будешь же ты все их сканировать вручную! Вот тут и вступает в игру zbar: быстрый, минималистичный и лёгкий инструмент для сканирования штрих- и QR-кодов прямо в ваших сценариях. Начнём с установки. Если у вас Linux, скорее всего, zbar уже можно поставить через пакетный менеджер, например:

sudo apt-get install libzbar0
pip install pyzbar

В Windows достаточно pip install pyzbar. Первый пример: минимализм во плоти Сканировать QR-код из изображения с помощью Python проще простого:

from pyzbar.pyzbar import decode
from PIL import Image

img = Image.open('qrcode_example.png')
decoded = decode(img)
for obj in decoded:
    print("Type:", obj.type)
    print("Data:", obj.data.decode('utf-8'))

Вот и всё! Код первым же вызовом вернёт вам содержимое QR-кода. Хотите прочитать несколько кодов на одном изображении — не проблема, цикл их вам покажет. Читаем QR-коды c веб-камеры Если у вас есть камера и библиотека OpenCV, можно ловить QR-коды в реальном времени:

import cv2
from pyzbar.pyzbar import decode

cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    for code in decode(frame):
        text = code.data.decode('utf-8')
        print("Found QR:", text)
    cv2.imshow('QR reader', frame)
    if cv2.waitKey(1) == 27:  # Esc для выхода
        break
cap.release()
cv2.destroyAllWindows()

Совет: кодировка часто бывает UTF-8, но лучше прописывать явно при декодировании. Zbar умеет находить и EAN, и CODE128, и DataMatrix — вдруг вам понадобится не только QR? Используйте zbar для автоматизации, распознавания купонов, генерации ссылок, билетов или входных ключей! Открывается целый мир автоматической обработки данных, а сам код всегда предельно лаконичен. Пробуйте, экспериментируйте и решайте задачи с минимальными усилиями! Ваша «магия» начинается с нескольких строк — а творить уже можно что угодно. На связи, Иван.

- Использование библиотеки zbar для обработки QR-кодов

Привет! С вами Иван, и сегодня у нас одна из самых необычных тем — погружение в мир AST (Abstract Syntax Tree) в Python. Если ты когда-нибудь мечтал покопаться под капотом языка, узнать, как Python понимает твой код перед исполнением — добро пожаловать! ### Что такое AST? AST — это "абстрактное синтаксическое дерево". Представь себе: любой Python-код сначала превращается в дерево объектов, которое структурирует код на уровни — функции, выражения, операторы, значения. Работа с AST похожа на анализ ДНК программы: ты можешь видеть, из чего состоит твой код, а иногда — даже переписать его на лету! ### Где это пригодится? - Статический анализ кода (например, поиск ошибок или автоматическая проверка стиля) - Автоматическая генерация кода - Рефакторинг ### Модуль ast — твой вход в AST Python предлагает встроенный модуль ast, который позволяет парсить исходный код и получать AST-дерево, исследовать его и даже модифицировать. #### Пример 1: Парсим простую функцию

import ast

source_code = """
def greet(name):
    return "Hello, " + name
"""

tree = ast.parse(source_code)
print(ast.dump(tree, indent=4))

Этот код превратит функцию greet в красивое дерево с вложенными нодами: FunctionDef, arguments, Return и т.д. #### Пример 2: Ищем все вызовы функций Хотим найти все места, где вызываются функции? (Call-ноды)

class CallVisitor(ast.NodeVisitor):
    def visit_Call(self, node):
        print("Function call found:", ast.dump(node))
        self.generic_visit(node)

tree = ast.parse("""
result = add(x, y)
print(result)
""")
CallVisitor().visit(tree)

#### Пример 3: Модификация кода на лету Пусть теперь программа заменяет все числа 42 на 100:

class ReplaceNumber(ast.NodeTransformer):
    def visit_Constant(self, node):
        if isinstance(node.value, int) and node.value == 42:
            return ast.Constant(value=100)
        return node

code = "answer = 42"
tree = ast.parse(code)
tree = ReplaceNumber().visit(tree)
exec(compile(tree, filename="<ast>", mode="exec"))
print(answer)  # Выведет 100

--- Используя AST, ты перестаешь быть просто пользователем языка — ты становишься его архитектором! Это мощный инструмент не только для изучения Python, но и для создания собственных инструментов для анализа и трансформации кода. Попробуй — и ты посмотришь на свой код другими глазами!

- Введение в генераторы AST (Abstract Syntax Tree) в Python

Привет! С вами Иван, и сегодня хочу поговорить о том, как работать с конфиденциальными данными в Python и не дать утечкам информации сломать вам карьеру (или, не дай бог, жизнь). Работая с конфиденциальной информацией — паролями, токенами, API-ключами, персональными данными — нельзя слепо полагаться на "авось пронесёт". Давайте пройдёмся по базовым, жизненно необходимым приемам защиты данных на практике. 1. Не храните секреты в коде Каждый видел примеры вроде:

password = "SuperSecret123"

Это антипаттерн! Любой, у кого есть доступ к коду, увидит ваш пароль. Используйте переменные окружения:

import os

password = os.getenv("DB_PASSWORD")

Храните настоящие значения в файле .env и никогда не загружайте его в git-репозиторий. 2. Используйте dotenv для удобства Модуль python-dotenv поможет легко считывать переменные окружения из файла. Просто создайте .env-файл:

DB_PASSWORD=SuperSecret123

И загрузите их:

from dotenv import load_dotenv
import os

load_dotenv()
password = os.getenv("DB_PASSWORD")

3. Никогда не логируйте чувствительные данные Если вы ведёте логи, не заносите в них пароли, токены, номера карт. Используйте параметр mask в логах своего приложения или самостоятельно следите, что именно выводит ваш print/logging:

import logging

logging.info("User logged in")  # А вот такого - избегайте: logging.info(f"Password: {password}")

4. Шифруйте данные на диске и в передаче Для простого симметричного шифрования идеально подходит модуль cryptography:

from cryptography.fernet import Fernet

key = Fernet.generate_key()
f = Fernet(key)

token = f.encrypt(b"My secret data")
print(token)
print(f.decrypt(token))

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