⚡️ Python-магия: Ускорение парсинга в 60 раз без сложного asyncio

Синхронный парсинг 1000 ссылок занимает около 5 минут.

Переписывать код на чистое asyncio не нужно.

🔹Решение: используйте связку httpx и anyio. httpx поддерживает асинхронный режим, а anyio упрощает параллельные запросы.

httpx умеет работать с синхронным и асинхронным режимом, а anyio под капотом делает параллельные запросы максимально удобными.

import httpx
import anyio
import time

urls = [f"https://jsonplaceholder.typicode.com/posts/{i}" for i in range(1000)]
start_time = time.time()

async def fetch(client, url, limiter):
    async with limiter:
        await client.get(url)

async def main():
    limiter = anyio.CapacityLimiter(100)  # макс. 100 параллельных запросов
    async with httpx.AsyncClient(timeout=30) as client:
        async with anyio.create_task_group() as task_group:
            for url in urls:
                task_group.start_soon(fetch, client, url, limiter)

anyio.run(main)
print(f"{len(urls)} запросов выполнено за {time.time() - start_time:.2f} секунд")

💡 По факту: эти 1 000 запросов теперь обрабатываются в ~7.25 секунд, в то время, как с обычным request обработка заняла ~439.82 секунд.

Да, почти в 60 раз быстрее — без заморочек с asyncio, event loop и сложными конструкциями.

Используйте httpx.AsyncClient, устанавливайте адекватный таймаут и всегда ограничивайте параллелизм с помощью CapacityLimiter.

🐍 Ghostly Python |#полезное

🐍 PyInstaller: Упакуй Python-приложение в один исполняемый файл

Хотите сделать свои Python-скрипты портативными? PyInstaller — ваше решение. Эта библиотека преобразует скрипты в самостоятельные исполняемые файлы, автоматически включая все необходимые зависимости.

Установка:

pip install pyinstaller.

Для создания одного файла-приложения используйте команду pyinstaller --onefile myscript.py.

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

👉 Ссылка

🐍 Ghostly Python |#полезное

❓ Вопрос с собеса

В чём разница между shallow copy и deep copy в Python?

Пример🔽

import copy

original = [[1, 2], [3, 4]]

shallow = copy.copy(original)
deep = copy.deepcopy(original)

original[0][0] = 99

print(shallow)  # ➔ [[99, 2], [3, 4]]
print(deep)     # ➔ [[1, 2], [3, 4]]

Ответ🔽

copy.copy() создаёт поверхностную копию объекта. Это значит, что сам объект копируется, но вложенные объекты продолжают ссылаться на те же данные.

copy.deepcopy() создаёт глубокую копию: копирует и сам объект, и все вложенные объекты, рекурсивно. В результате оригинал и копия полностью независимы.

🟢 Когда использовать:

copy() — если объект неглубокий и вложенные данные не будут изменяться.

deepcopy() — если нужно полностью изолировать копию от оригинала, включая всё содержимое.

❗️Важно: deepcopy может быть медленным на больших и вложенных структурах. Используйте осознанно.

📌 Подходит для работы со сложными структурами данных: списками списков, словарями, графами и т.д.

🐍 Ghostly Python | #собес

🖼️ Библиотека: FastAPI-Users

FastAPI-Users — это библиотека для быстрой интеграции системы аутентификации и управления пользователями в приложениях на FastAPI. Она предоставляет готовые модели, маршруты и утилиты для регистрации, входа, восстановления пароля, верификации email и управления сессиями.

ℹ️ Основные возможности:

🟢 Готовая аутентификация через JWT, cookie, OAuth2 (Google, GitHub и др.)
🟢 Управление аккаунтом (изменение данных, деактивация)
🟢 Поддержка SQLAlchemy, MongoDB, Tortoise ORM
🟢 Интеграция с FastAPI без boilerplate-кода

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

from fastapi import FastAPI
from fastapi_users import FastAPIUsers, models
from fastapi_users.authentication import JWTAuthentication
from fastapi_users.db import SQLAlchemyBaseUserTable, SQLAlchemyUserDatabase
from sqlalchemy.ext.declarative import DeclarativeMeta, declarative_base
import sqlalchemy as sa

SECRET_KEY = "mysecretkey"
DATABASE_URL = "sqlite:///./test.db"

Base: DeclarativeMeta = declarative_base()

class UserTable(Base, SQLAlchemyBaseUserTable):
    pass

class User(models.BaseUser):
    pass

class UserCreate(models.BaseUserCreate):
    pass

class UserUpdate(User, models.BaseUserUpdate):
    pass

class UserDB(User, models.BaseUserDB):
    pass

engine = sa.create_engine(DATABASE_URL)
Base.metadata.create_all(engine)

async def get_user_db():
    yield SQLAlchemyUserDatabase(UserDB, engine, UserTable.__table__)

jwt_authentication = JWTAuthentication(
    secret=SECRET_KEY, lifetime_seconds=3600, tokenUrl="auth/jwt/login"
)

fastapi_users = FastAPIUsers(
    get_user_db,
    [jwt_authentication],
    User,
    UserCreate,
    UserUpdate,
    UserDB,
)

app = FastAPI()

app.include_router(
    fastapi_users.get_auth_router(jwt_authentication),
    prefix="/auth/jwt",
    tags=["auth"],
)
app.include_router(
    fastapi_users.get_register_router(),
    prefix="/auth",
    tags=["auth"],
)

@app.get("/protected-route")
async def protected_route(user: User = fastapi_users.current_user()):
    return {"message": f"Hello, {user.email}!"}

✔️ Установка:

pip install fastapi-users[sqlalchemy]

➡️ Ссылка на документацию

🐍 Ghostly Python | #библиотеки

🐍 Ghostly Python | #мемы

📱 Фишка: functools.singledispatch — перегрузка функций для разных типов аргументов

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

from functools import singledispatch
from decimal import Decimal

@singledispatch
def pretty_format(data):
    """Базовый обработчик, вызывается, если тип не найден."""
    return f"Неизвестный тип: {type(data).__name__}"

@pretty_format.register(str)
def _(text):
    return f"Строка: '{text}' (длина: {len(text)})"

@pretty_format.register(int)
def _(number):
    return f"Целое число: {number:#x} (шестнадцатеричное)"

@pretty_format.register(list)
def _(items):
    items_str = ", ".join(map(str, items))
    return f"Список [{items_str}] из {len(items)} элементов"

@pretty_format.register(float)
@pretty_format.register(Decimal)
def _(num):
    return f"Дробное число: {num:.2f}"

print(pretty_format("Привет"))        # ➔ Строка: 'Привет' (длина: 6)
print(pretty_format(42))              # ➔ Целое число: 0x2a (шестнадцатеричное)
print(pretty_format([1, 2, 3]))       # ➔ Список [1, 2, 3] из 3 элементов
print(pretty_format(3.14159))         # ➔ Дробное число: 3.14
print(pretty_format({"key": "val"}))  # ➔ Неизвестный тип: dict (вызвана базовая функция)

# Изменили оригинал — прокси «увидит» это settings["port"] = 9000
# (Эта строка из примера с MappingProxyType здесь не относится, оставлена для аналогии с вашим шаблоном)

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

🟢 Динамическая диспетчеризация: При вызове pretty_format(arg) декоратор автоматически смотрит на тип arg и выбирает зарегистрированную для этого типа функцию.

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

🟢 Иерархия типов: Если для точного типа нет обработчика, можно использовать register() для базовых классов (например, numbers.Integral).

🟢 Чистая архитектура: Избавляет от длинных цепочек if isinstance(...) внутри одной функции, делая код модульным и легко поддерживаемым.

🐍 Ghostly Python | #фишки

👩‍💻 Викторина: что выведет код?

def tricky(x, y=[]):
    if not y:
        z = x.copy()
    else:
        z = x
    z.append(id(y))
    return z is x, z

a = [1, 2]
b = [3, 4]

r1 = tricky(a)
r2 = tricky(b, a)
r3 = tricky(b)

print(r1[0], r2[0], r3[0])
print(r1[1], r2[1], r3[1])

🐍 Ghostly Python | #викторина

⚙️ Управление процессами на Python с помощью subprocess

subprocess — встроенный модуль Python для запуска внешних программ, выполнения команд shell и взаимодействия с процессами. Полезен при автоматизации, DevOps-скриптах и интеграции с CLI-инструментами.

✔️ Стандартная библиотека — установка не требуется

⚙️ Пример: выполнение shell-команды

import subprocess

# Выполняем команду ls (или dir на Windows)
result = subprocess.run(["ls", "-l"], capture_output=True, text=True)

# Печатаем результат
print(result.stdout)

💬 Как это работает:

1. subprocess.run([...]) запускает команду и ожидает завершения.
2. capture_output=True сохраняет вывод команды.
3. text=True возвращает результат в виде строки (а не байтов).

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

🐍 Ghostly Python | #гайды

Хороший айтишник ≠ хороший руководитель

И это причина, почему большинство застревают в своем развитии.

📊 Управление — это отдельный навык.

В канале Апазиди АйТи показывают, как его развить в реальном IT.

▪️управленческие ошибки, которые тихо ломают карьеру

▪️почему созвоны — признак слабой системы

▪️как строить команды без постоянного контроля

Читай тут: 👉 https://t.me/+Jcx__bY56BwwN2Uy

📱 Фишка: base64 — кодирование и декодирование данных

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

import base64  

message = b"Hello, world!"  

# Кодируем в Base64  
encoded = base64.b64encode(message)  
print(encoded.decode())  # SGVsbG8sIHdvcmxkIQ==  

# Декодируем обратно  
decoded = base64.b64decode(encoded)  
print(decoded.decode())  # Hello, world!

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

🟢 b64encode() преобразует данные в безопасный текстовый формат.
🟢 b64decode() возвращает исходные двоичные данные.
🟢 Используется для передачи данных в URL, API и хранения файлов в текстовом формате.

🐍 Ghostly Python | #фишки

📱 Фишка: call — делаем объекты вызываемыми как функции

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

class Counter:
def init(self):
self.count = 0
def __call__(self):  
    self.count += 1  
    return self.count  

Создаём объект

counter = Counter()

Вызываем объект как функцию

print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

---

Более практичный пример: кэширующий декоратор на классе
class Memoize:
    def __init__(self, func):
        self.func = func
        self.cache = {}

    def __call__(self, *args):
        if args not in self.cache:
            self.cache[args] = self.func(*args)
        return self.cache[args]

@Memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # Быстро, т.к. значения кэшируются

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

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

🐍 Ghostly Python | #фишки

🐍 Ghostly Python | #мемы

👩‍💻 Викторина: что выведет код?

import time

class CodeQuiz:
    def __init__(self):
        self.questions = [
            {
                "code": "print([i**2 for i in range(5)])",
                "options": ["[0, 1, 4, 9, 16]", "[1, 4, 9, 16, 25]", "[0, 2, 4, 6, 8]", "Ошибка"],
                "answer": 0
            },
            {
                "code": "x = 'hello'\nprint(x[::-1])",
                "options": ["hello", "olleh", "h", "Ошибка"],
                "answer": 1
            },
            {
                "code": "a = {1, 2, 3}\nb = {3, 4, 5}\nprint(a & b)",
                "options": ["{1, 2, 3, 4, 5}", "{3}", "{ }", "Ошибка"],
                "answer": 1
            }
        ]
        self.score = 0

    def run(self):
        print("Викторина: Что выведет код?\n")
        
        for i, q in enumerate(self.questions, 1):
            print(f"Вопрос {i}:")
            print(q["code"])
            print("\nВарианты:")
            for idx, opt in enumerate(q["options"]):
                print(f"{idx+1}) {opt}")
            
            try:
                ans = int(input("\nОтвет (1-4): ")) - 1
                if ans == q["answer"]:
                    print("✓ Правильно!\n")
                    self.score += 1
                else:
                    print(f"✗ Неправильно. Правильный ответ: {q['options'][q['answer']]}\n")
            except:
                print("Нужно ввести число 1-4\n")
        
        print(f"Итог: {self.score}/{len(self.questions)}")

quiz = CodeQuiz()
quiz.run()

🐍 Ghostly Python | #викторина

🐍 Ghostly Python | #мемы

➡️ Python Tutor — визуализатор выполнения Python-кода в браузере

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

Примечательно, что сервис поддерживает пошаривание сессий и встроенные “сценарии” с примерами — удобно разбирать код с командой или наставником прямо по ссылке.

⛓️ Ссылка на ресурс

🐍 Ghostly Python | #ресурсы

❓ Вопрос с собеса: генераторы vs списки в Python

На собеседованиях по Python часто спрашивают про разницу между генераторами и списками. Давайте разберем на примере.

Пример🔽

# Создание списка
list_numbers = [x * 2 for x in range(5)]
print("Список:", list_numbers)  # → [0, 2, 4, 6, 8]

# Создание генератора
gen_numbers = (x * 2 for x in range(5))
print("Генератор:", gen_numbers)  # → <generator object at ...>
print("Элементы генератора:", list(gen_numbers))  # → [0, 2, 4, 6, 8]

Ответ🔽

Список ([]) — хранит все элементы сразу в памяти.
Подходит, если нужно многократно обращаться к данным или изменять их.

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

— Когда что использовать?
Список — если нужен быстрый доступ по индексу или многоразовое использование данных.

Генератор — если работаете с большим объёмом данных или нужно экономить память.

🐍 Ghostly Python | #собес

🖼️ Библиотека: TextBlob

TextBlob — это интуитивно понятная библиотека для обработки текста на Python, построенная поверх NLTK и Pattern. Предоставляет простой API для распространённых NLP-задач: анализ тональности, перевод, извлечение существительных, классификация и многое другое.

ℹ️ Основные возможности:

🟢 Анализ тональности: Определение полярности и субъективности текста.
🟢 Частеречная разметка (POS-tagging): Автоматическое определение частей речи.
🟢 Извлечение существительных и фраз: Нахождение ключевых слов и тем.
🟢 Морфологический анализ: Склонение, спряжение, единственное/множественное число.
🟢 Перевод и определение языка: Интеграция с Google Translate.

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

from textblob import TextBlob
from collections import Counter

# Чтение файла
with open('article.txt', 'r', encoding='utf-8') as f:
    text = f.read()

# Создание объекта TextBlob
blob = TextBlob(text)

# Основная статистика
print(f"Длина текста: {len(text)} символов")
print(f"Количество слов: {len(blob.words)}")
print(f"Количество предложений: {len(blob.sentences)}")
print(f"Средняя длина предложения: {len(blob.words)/len(blob.sentences):.1f} слов")
print()

# Самые частые слова (без стоп-слов)
words = [word.lower() for word in blob.words if len(word) > 3]
word_freq = Counter(words).most_common(10)
print("=== ТОП-10 СЛОВ ===")
for word, count in word_freq:
    print(f"{word:15} : {count} раз")
print()

# Анализ тональности по предложениям
print("=== ТОНАЛЬНОСТЬ ПО ПРЕДЛОЖЕНИЯМ ===")
for i, sentence in enumerate(blob.sentences[:5], 1):
    print(f"[{i}] {sentence}")
    print(f"    Полярность: {sentence.sentiment.polarity:.3f}")
    print()

✔️ Установка:

pip install textblob

➡️ Ссылка на документацию

🐍 Ghostly Python | #библиотеки