❗️ Создание динамических классов и функций с помощью type() и метаклассов


В Python все является объектом, даже сами классы. Это открывает перед нами удивительные возможности для создания динамических структур кода. Давайте погрузимся в мир создания классов и функций "на лету" с помощью type() и метаклассов.

➡️Магия функции type()

Функция type() в Python - это не просто инструмент для определения типа объекта. Она также может быть использована для создания новых классов динамически. Вот простой пример:

MyClass = type('MyClass', (), {'x': 42, 'my_method': lambda self: print("Hello!")})

obj = MyClass()
print(obj.x)  # Выведет: 42
obj.my_method()  # Выведет: Hello!

Здесь мы создали класс MyClass с атрибутом x и методом my_method. Удивительно, правда?

➡️Шаг вперед: метаклассы

Метаклассы - это классы классов. Они позволяют нам контролировать процесс создания классов. Рассмотрим пример:

class MyMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['additional_method'] = lambda self: print("I'm additional!")
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMetaclass):
    pass

obj = MyClass()
obj.additional_method()  # Выведет: I'm additional!

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

➡️Практическое применение

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

- Фабрики классов: создание классов на основе внешних данных или конфигурации.
- Декораторы классов: модификация классов без изменения их исходного кода.
- ORM (Object-Relational Mapping): динамическое создание классов на основе структуры базы данных.

🫣🫣 Скрытые возможности библиотеки functools в Python


Библиотека functools в Python - это настоящая сокровищница для разработчиков, стремящихся оптимизировать свой код и расширить функциональные возможности языка. Хотя многие знакомы с такими популярными инструментами, как @lru_cache@lru_cache и partial, эта библиотека скрывает ряд менее известных, но не менее полезных функций.

➡️ reduce(): мощь функционального программирования


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

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

from functools import reduce

numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # Выведет: 120

➡️ singledispatch: элегантное решение для перегрузки функций


@singledispatch@singledispatch позволяет создавать функции, которые ведут себя по-разному в зависимости от типа переданного аргумента. Это элегантная альтернатива множественным условным операторам.

from functools import singledispatch

@singledispatch
def process(arg):
    print(f"Обработка объекта: {arg}")

@process.register(int)
def _(arg):
    print(f"Обработка целого числа: {arg}")

@process.register(list)
def _(arg):
    print(f"Обработка списка длиной {len(arg)}")

process("строка")  # Обработка объекта: строка
process(42)        # Обработка целого числа: 42
process([1, 2, 3]) # Обработка списка длиной 3

➡️ total_ordering: автоматическое создание методов сравнения

Декоратор @total_ordering@total_ordering значительно упрощает реализацию классов, поддерживающих операции упорядочивания. Достаточно определить методы eq() и один из методов сравнения (lt, le, gt или ge), а остальные будут автоматически созданы.

from functools import total_ordering

@total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        return self.age == other.age

    def __lt__(self, other):
        return self.age < other.age

p1 = Person("Алиса", 25)
p2 = Person("Боб", 30)

print(p1 < p2)  # True
print(p1 <= p2) # True
print(p1 > p2)  # False
print(p1 >= p2) # False

➡️ cache: простая альтернатива lru_cache

Функция cache предоставляет простой способ кэширования результатов функции без ограничения размера кэша. Это может быть полезно, когда вы уверены, что количество уникальных входных данных ограничено.

from functools import cache

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

print(fibonacci(100))  # Мгновенный результат даже для больших чисел

➡️ wraps: сохранение метаданных функции

Декоратор @wraps@wraps помогает сохранить метаданные оригинальной функции при создании декораторов. Это особенно важно при использовании инструментов документации и отладки.

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """Это документация обертки"""
        print("До вызова функции")
        result = func(*args, **kwargs)
        print("После вызова функции")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    """Приветствует пользователя по имени"""
    print(f"Привет, {name}!")

say_hello("Мария")
print(say_hello.__name__)  # Выведет: say_hello
print(say_hello.__doc__)   # Выведет: Приветствует пользователя по имени

🔝🔝 Отличный хостинг, который я часто рекомендую, теперь еще и со скидкой! 🔝

Сейчас у Hostetski крутая акция — это ваш шанс воспользоваться отличным сервисом по выгодной цене! 💥

Узнайте все подробности тут 👉 Акция от Hostetski👉 Акция от Hostetski

Не упустите шанс вывести свои проекты на новый уровень с топовым хостингом!

Привет, питонисты! Сегодня мы погрузимся в мир профилирования и оптимизации памяти в Python. Держите ваши кружки с кофе наготове — будет интересно!

❗️ Зачем вообще париться с памятью в Python?

Казалось бы, Python — язык высокого уровня с автоматическим управлением памятью. Зачем нам вообще беспокоиться об этом? Но, друзья мои, даже в Пайтоне память не бесконечна. Особенно когда вы работаете с большими данными или создаете высоконагруженные приложения.

❗️memory_profiler: ваш верный спутник

memory_profiler — это как швейцарский нож для анализа памяти. Вот пример его использования:

from memory_profiler import profile

@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

if __name__ == '__main__':
    my_func()

Запустите скрипт с помощью python -m memory_profiler script.py, и вы увидите подробный отчет о использовании памяти. Красота, правда?

❗️line_profiler: когда нужна точность до строчки

Если memory_profiler — это швейцарский нож, то line_profiler — это микроскоп. Он покажет вам использование памяти построчно:

@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

my_func()

Запустите с помощью kernprof -l -v script.py, и вы увидите, какая строчка сколько памяти съедает.

❗️objgraph: визуализируем объекты

objgraph — это как рентген для вашего кода. Он позволяет визуализировать объекты в памяти:

import objgraph

x = []
y = [x, [x], dict(x=x)]
objgraph.show_refs([y], filename='sample-graph.png')

Запустите это, и вы получите красивую картинку связей между объектами. Полезно для поиска утечек памяти!

❗️tracemalloc: встроенная мощь Python

А теперь — жемчужина в короне Python 3. tracemalloc — это встроенный модуль для отслеживания выделения памяти:

import tracemalloc

tracemalloc.start()

# ваш код здесь

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

print("[ Топ 10 ]")
for stat in top_stats[:10]:
    print(stat)

Это как рентген, МРТ и УЗИ в одном флаконе. Вы увидите, где именно происходят утечки памяти.

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🤨🤨🤨🤨🤨🤨
Кто дебажит принтом?? Будет полезно!

https://youtu.be/TW97b2PQy9shttps://youtu.be/TW97b2PQy9s

❗️❗️ Нестандартное использование Python decorators: примеры сложных и креативных применений

Привет, питонисты! Сегодня мы нырнем в глубины Python и раскопаем настоящие жемчужины — нестандартные способы использования декораторов. Держитесь крепче, будет интересно!

😬 Декораторы на стероидах: когда обычных функций мало

Помните, как вы впервые узнали о декораторах? Наверняка это было что-то вроде @staticmethod@staticmethod или простенького таймера. Но, друзья мои, это лишь верхушка айсберга! Давайте посмотрим, как можно выжать из декораторов все соки.

➡️1. Декоратор-шпион: следим за аргументами

import functools

def spy_args(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Вызов {func.__name__} с аргументами: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@spy_args
def секретная_функция(x, y, шифр="007"):
    return x + y

результат = секретная_функция(3, 4, шифр="008")

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

➡️2. Декоратор-трансформер: меняем возвращаемое значение

def to_json(func):
    import json
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return json.dumps(result)
    return wrapper

@to_json
def получить_данные():
    return {"имя": "Алиса", "возраст": 30}

json_data = получить_данные()

Этот декоратор автоматически сериализует результат в JSON. Удобно, правда? Особенно когда вы работаете с API и вам нужно гарантировать формат ответа.

➡️3. Декоратор-многостаночник: применяем несколько функций

def применить_все(*funcs):
    def декоратор(f):
        @functools.wraps(f)
        def wrapper(*args, **kwargs):
            result = f(*args, **kwargs)
            for func in funcs:
                result = func(result)
            return result
        return wrapper
    return декоратор

def удвоить(x): return x * 2
def прибавить_один(x): return x + 1

@применить_все(удвоить, прибавить_один)
def базовая_функция(x):
    return x

результат = базовая_функция(10)  # Вернёт 21

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

➡️4. Декоратор-ленивец: отложенное выполнение

class Ленивый:
    def __init__(self, function):
        self.function = function
        self.результат = None

    def __call__(self, *args, **kwargs):
        if self.результат is None:
            self.результат = self.function(*args, **kwargs)
        return self.результат

@Ленивый
def сложные_вычисления():
    print("Выполняю сложные вычисления...")
    return 42

результат = сложные_вычисления()  # Вычисления выполняются
результат = сложные_вычисления()  # Используется кэшированный результат

Этот декоратор позволяет отложить выполнение функции до момента первого вызова, а затем кэширует результат. Идеально для оптимизации производительности!

Заключение: декораторы — ваш секретный ингредиент

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

❗️❗️Асинхронные генераторы в Python: мощь и практика

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

➡️ Что такое асинхронный генератор?

Представьте обычный генератор, но на стероидах. Асинхронный генератор — это функция, которая использует async def и yield для создания асинхронного итератора. Звучит сложно? На самом деле, это просто способ лениво создавать последовательность значений, не блокируя основной поток выполнения.

➡️ Зачем они нужны?

Асинхронные генераторы особенно полезны, когда вы работаете с I/O-bound задачами. Например, при обработке больших объёмов данных из сети или файловой системы. Они позволяют эффективно управлять памятью и повышают отзывчивость приложения.

➡️ Как это выглядит на практике?

async def async_range(start, stop):
    for i in range(start, stop):
        await asyncio.sleep(0.1)
        yield i

async def main():
    async for num in async_range(0, 5):
        print(num)

asyncio.run(main())

В этом примере async_range имитирует долгую операцию с помощью asyncio.sleep. В реальном коде вместо sleep могла бы быть работа с базой данных или API.

➡️ Где это реально пригодится?

1. Парсинг данных: Представьте, что вам нужно обработать гигабайты логов. Асинхронный генератор позволит читать и обрабатывать данные порциями, не загружая всё в память разом.
2. Стриминг данных: При работе с потоковым API вы можете использовать асинхронный генератор для обработки данных по мере их поступления.
3. Пагинация: Если вы работаете с API, которое возвращает данные постранично, асинхронный генератор может абстрагировать логику пагинации, предоставляя удобный интерфейс для работы с данными.

➡️ Подводные камни

Помните, что асинхронные генераторы работают только внутри асинхронного кода. Их нельзя использовать в синхронных функциях. Кроме того, они могут быть сложнее для понимания и отладки, особенно для новичков в асинхронном программировании.

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🤖🤖 9 инструментов программирования ИИ с открытым исходным кодом для разработчиков ЧАСТЬ ЧАСТЬ 2️⃣2️⃣2️⃣

➡️5. Continue — ведущий помощник по написанию кода на базе ИИ

Continue похож на популярную среду IDE Cursor, но имеет открытый исходный код под лицензией Apache. Он очень настраиваемый и позволяет добавлять любую языковую модель для автодополнения или чата.

😡 Основные характеристики:

- Общение в чате для понимания и переработки кода в боковой панели
- Автозаполнение для получения встроенных предложений кода по мере ввода текста
- Редактирование кода без необходимости покидать текущий файл
- Действия по созданию ярлыков для повседневных случаев использования

➡️ 6. Qodo Merge: инструмент для автоматизированного анализа запросов на извлечение

Qodo Merge - это инструмент с открытым исходным кодом от Codium AI, который автоматизирует обзор, анализ, обратную связь и предложения для запросов на извлечение GitHub. Он совместим с другими системами контроля версий, такими как GitLab и BitBucket.

❓ Как использовать Qodo Merge:

pip install pr-agent

from pr_agent import cli
from pr_agent.config_loader import get_settings

def main():
    provider = "github"
    user_token = "..."
    openai_key = "..."
    pr_url = "..."
    command = "/review"

    get_settings().set("CONFIG.git_provider", provider)
    get_settings().set("openai.key", openai_key)
    get_settings().set("github.user_token", user_token)

    cli.run_command(pr_url, command)

if __name__ == '__main__':
    main()

➡️ 7. OpenHands: Платформа для разработчиков программного обеспечения на основе ИИ

OpenHands - одна из ведущих платформ с открытым исходным кодом для агентов ИИ. Агент OpenHands может создавать новые проекты с нуля, добавлять функции в существующие кодовые базы, отлаживать проблемы и многое другое.

❓ Как запустить OpenHands:

docker pull docker.all-hands.dev/all-hands-ai/runtime:0.12-nikolaik
docker run -it --rm --pull=always \
    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.12-nikolaik \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    docker.all-hands.dev/all-hands-ai/openhands:0.12

После запуска OpenHands будет доступен по адресу http://localhost:3000/.

➡️ 8. Cody из Sourcegraph: помощник по кодированию для IDE

Cody - это проект с открытым исходным кодом от Sourcegraph, призванный ускорить ваш рабочий процесс кодирования непосредственно в вашей IDE. Он использует расширенный поиск в качестве помощника по кодированию для извлечения контекста из локальных и удаленных кодовых баз.

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

- Общение с базой кода
- Внесение встроенных правок
- Получение предложений по коду
- Автодополнение

➡️ 9. VannaAI: Чат с базой данных SQL

VannaAI - это инструмент с открытым исходным кодом, позволяющий общаться с базами данных SQL, используя естественный язык. Он особенно полезен для тех, кто испытывает трудности с написанием SQL-запросов.

❓ Как начать работу с VannaAI:

pip install vanna

from vanna.openai.openai_chat import OpenAI_Chat
from vanna.chromadb.chromadb_vector import ChromaDB_VectorStore

class MyVanna(ChromaDB_VectorStore, OpenAI_Chat):
    def __init__(self, config=None):
        ChromaDB_VectorStore.__init__(self, config=config)
        OpenAI_Chat.__init__(self, config=config)

vn = MyVanna(config={'api_key': 'sk-...', 'model': 'gpt-4-...'})

# Обучение модели
vn.train(ddl="""
    CREATE TABLE IF NOT EXISTS my-table (
        id INT PRIMARY KEY,
        name VARCHAR(100),
        age INT
    )
""")

# Задать вопрос
sql_query = vn.ask("What are the top 10 customers by sales?")
print(sql_query)

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🤖🤖 9 инструментов программирования ИИ с открытым исходным кодом для разработчиков


➡️1. SWE-Kit: IDE с открытым исходным кодом для кодирующих агентов

SWE-Kit представляет собой headless IDE с такими функциями, как LSP (Language Server Protocol), индексация кода и Code RAG (Retrieval-Augmented Generation). Он предлагает гибкую среду выполнения, которая может работать на любом хосте Docker или удаленном сервере, а также специализированные наборы инструментов для кодирования.

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

- Интеграция с платформами GitHub, Jira и Slack
- Инструменты поиска файлов и индексации кода
- Совместимость с фреймворками LLM, такими как LangChain, CrewAI, Autogen и LlamaIndex

❓ Как начать работу с SWE-Kit:

pip install compsio-core swekit
pip install crewai composio-crewai
composio add github
swekit scaffold crewai -o swe_agent
cd swe_agent/agent
python main.py

SWE-Kit позволяет создавать и развертывать собственные агенты, такие как GitHub PR Agent для автоматизации проверки Pull Request, агент SWE для автоматического написания функций, модульных тестов и документации, а также инструмент для чата с кодовой базой.

➡️ 2. Aider - AI Pair-программист

Aider - это идеальный выбор для тех, кто ищет виртуального парного программиста. Он позволяет связать программы с моделями машинного обучения (LLM) для редактирования кода в вашем локальном репозитории GitHub.

❓ Как начать работу с Aider:

pip install aider-chat
cd /to/your/git/repo
export ANTHROPIC_API_KEY=your-key-goes-here
aider
# Или для работы с GPT-4
export OPENAI_API_KEY=your-key-goes-here
aider

➡️ 3. Mentat — собственный агент кодирования GitHub

Mentat - это инструмент на основе ИИ, призванный помочь разработчикам справиться с любой задачей по написанию кода из командной строки. В отличие от других инструментов, Mentat может координировать правки в нескольких файлах и понимает контекст проекта с самого начала.

❓ Как установить и запустить Mentat:

python3 -m venv .venv
source .venv/bin/activate
git clone https://github.com/AbanteAI/mentat.git
cd mentat
pip install -e .
export OPENAI_API_KEY=
mentat 

➡️ 4. AutoCodeRover — усовершенствование автономной программы

AutoCodeRover предлагает полностью автоматизированное решение для устранения проблем GitHub, включая исправление ошибок и добавление функций. Он объединяет LLM с расширенными возможностями анализа и отладки для эффективного создания и внедрения исправлений.

❓ Как запустить AutoCodeRover:

export OPENAI_KEY=sk-YOUR-OPENAI-API-KEY-HERE
docker build -f Dockerfile -t acr .
docker run -it -e OPENAI_KEY="${OPENAI_KEY:-OPENAI_API_KEY}" -p 3000:3000 -p 5000:5000 acr

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

https://youtu.be/MjJv14WohL4

💡💡 Как использовать лямбда-функции в Python

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

➡️Что такое лямбда-функции?

Лямбда-функции определяются с помощью ключевого слова lambda, в отличие от обычных функций, которые определяются с помощью def. Они позволяют писать более чистый и читаемый код, устраняя необходимость во временных определениях функций.

➡️ Синтаксис лямбда-функций

lambda arguments: expression

Например, простая лямбда-функция для сложения двух чисел:

add = lambda x, y: x + y
result = add(3, 5)
print(result)  # Выведет: 8

➡️ Распространенные случаи использования

1. С функцией map()

map() применяет функцию к каждому элементу итерируемого объекта:

numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # Выведет: [1, 4, 9, 16]

2. С функцией filter()

filter() используется для фильтрации элементов:

numbers = [1, 2, 3, 4]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # Выведет: [2, 4]

3. С функцией sorted()

sorted() позволяет сортировать элементы по заданному критерию:

points = [(1, 2), (3, 1), (5, -1)]
points_sorted = sorted(points, key=lambda point: point[1])
print(points_sorted)  # Выведет: [(5, -1), (3, 1), (1, 2)]

➡️ Преимущества использования лямбда-функций

- Краткость и читаемость для простой логики
- Расширенные возможности функционального программирования
- Удобны для "одноразовых" функций

➡️ Ограничения и недостатки

- Могут быть сложны для чтения при использовании в сложных выражениях
- Ограничения в обработке ошибок и отладке
- Ограниченная функциональность (только одно выражение)

➡️ Вложенные лямбда-функции

nested_lambda = lambda x: (lambda y: y ** 2)(x) + 1
print(nested_lambda(3))  # Выведет: 10

➡️ Интеграция с библиотеками

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

import pandas as pd

data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)
df['C'] = df.apply(lambda row: row['A'] + row['B'], axis=1)
print(df)

➡️ ЗаключениеЗаключение

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

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🖥🖥 Хотели захостить сайт на фласке, подключить html?

И все это за 5 минут и бесплатно? Вот решение!

https://youtu.be/4jxMhmVGFt0

🫠🫠 Python — жадные алгоритмы для задач оптимизации

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

➡️ Пример — жадный алгоритм для дробной задачи о рюкзаке на Python

def fractional_knapsack(items, capacity):
    # Sort items by their value-to-weight ratio in descending order
    items.sort(key=lambda x: x[1] / x[0], reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for item in items:
        if remaining_capacity >= item[0]:
            total_value += item[1]
            remaining_capacity -= item[0]
        else:
            total_value += (remaining_capacity / item[0]) * item[1]
            break

    return total_value

# Example usage:
items = [(2, 10), (3, 5), (5, 15), (7, 7), (1, 6)]
knapsack_capacity = 10
max_value = fractional_knapsack(items, knapsack_capacity)
print(max_value)

➡️ Объяснение алгоритма

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

➡️ Применение жадных алгоритмов

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

🙂🙂 Реализация кучи на Python 💩

Куча [чего? Что на картинке?] (heap) - это элегантная структура данных, которая часто используется для реализации приоритетной очереди. В то время как приоритетная очередь - это абстрактная структура данных, определяющая поведение и интерфейс, куча - это конкретная реализация, определяющая, как эта структура работает.

➡️ Основные операции

Реализация приоритетной очереди обычно предоставляет следующие методы:

- Вставить(H, x): вставить элемент x в приоритетную очередь H
- Find(H): вернуть элемент с наивысшим приоритетом в очереди H
- Delete(H): удалить элемент с наименьшим (или наибольшим) значением в очереди H

➡️ Бинарная куча

В этой статье мы сосредоточимся на реализации бинарной кучи (Binary Heap), где каждый узел может иметь максимум двух потомков. В min-heap родительский узел всегда имеет меньшее значение, чем его потомки, а в max-heap - большее.

➡️ Представление данных

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

- Индекс левого потомка: 2*k + 1
- Индекс правого потомка: 2*k + 2
- Индекс родителя: (k - 1) // 2

➡️ Применение куч

Кучи находят широкое применение в различных алгоритмах и реальных сценариях:

- Сортировка: пирамидальная сортировка (Heapsort) имеет временную сложность O(n log n) в худшем случае
- Алгоритмы поиска на графах: A* и алгоритм Дейкстры используют кучи для хранения пар приоритет-узел
- Кодирование Хаффмана: кучи применяются для хранения и извлечения деревьев с наименьшей частотой

➡️ Реализация в Python

В стандартной библиотеке Python API для работы с кучами находится в модуле heapq. Вот пример использования:

import heapq

unsorted_array = [100, 230, 44, 1, 74, 12013, 84]
heapq.heapify(unsorted_array)
print(unsorted_array)
# [1, 74, 44, 230, 100, 12013, 84]

sorted_array = []
for _ in range(len(unsorted_array)):
    sorted_array.append(heapq.heappop(unsorted_array))
print(sorted_array)
# [1, 44, 74, 84, 100, 230, 12013]

➡️ Собственная реализация MinHeap

Ниже представлена базовая структура класса MinHeap с основными методами:

class MinHeap:
    def __init__(self):
        self.nodes = []

    def add(self, item):
        self.nodes.append(item)
        self.__heapify_up()

    def poll(self):
        if self.is_empty():
            return None
        removed_node = self.nodes[0]
        self.nodes[0] = self.nodes[-1]
        del self.nodes[-1]
        self.__heapify_down()
        return removed_node

    def peek(self):
        return self.nodes[0] if not self.is_empty() else None

    def is_empty(self):
        return len(self.nodes) == 0

    def __heapify_up(self):
        # Реализация метода подъема элемента

    def __heapify_down(self):
        # Реализация метода опускания элемента

➡️ Заключение

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

🔥🔥 Изучение хэш-функций в Python: распределение, коллизии и производительность

Хэш-функции играют важную роль в компьютерных науках, особенно в структурах данных и криптографии. В этой статье мы рассмотрим различные типы хэш-функций, реализованные на Python, и проанализируем их характеристики.

➡️ Типы хэш-функций

➡️1. Простая хэш-функция (simple_hash)

Эта функция суммирует ASCII-значения символов входной строки и применяет операцию модуля. Она проста в реализации, но может привести к неравномерному распределению.

def simple_hash(input_str, table_size):
    hash_value = 0
    for char in input_str:
        hash_value += ord(char)
    return hash_value % table_size

➡️ 2. Полиномиальный хэш (polynomial_hash)

Использует полиномиальное накопление ASCII-значений с простым числом, что позволяет придать больший вес символам в начале строки.

def polynomial_hash(input_str, table_size, prime=31):
    hash_value = 0
    for i, char in enumerate(input_str):
        hash_value += ord(char) * (prime ** i)
    return hash_value % table_size

➡️ 3. FNV-1a хэш (fnv1a_hash)

32-битная версия FNV-1a хэша, известная своими хорошими характеристиками распределения.

def fnv1a_hash(key, table_size):
    FNV_prime = 16777619
    FNV_offset_basis = 2166136261
    hash_value = FNV_offset_basis
    for char in key:
        hash_value ^= ord(char)
        hash_value *= FNV_prime
        hash_value &= 0xffffffff  # Обеспечивает 32-битный хэш
    return hash_value % table_size

➡️ 4. XXХэш (xx_hash)

Использует библиотеку xxhash для быстрого некриптографического хэширования, эффективного для больших объемов данных.

def xx_hash(input_str, table_size):
    return xxhash.xxh32(input_str).intdigest() % table_size

➡️ 5. SipHash (sip_hash)

Применяет HMAC с SHA-256 для повышенной безопасности, но может быть медленнее некриптографических хэшей.

def sip_hash(input_str, table_size, key=b'secretkey'):
    hash_value = hmac.new(key, input_str.encode(), digestmod='sha256').hexdigest()
    return int(hash_value, 16) % table_size

➡️ 6. MurmurHash (murmur_hash)

Быстрая некриптографическая хэш-функция, часто используемая в хэш-таблицах и фильтрах Блума.

def murmur_hash(input_str, table_size):
    hash_value = mmh3.hash(input_str) % table_size
    return hash_value

➡️ Тестирование хэш-функций

➡️ Генерация тестовых данных

Для тестирования используется функция generate_random_strings, которая создает случайные строки заданной длины.

➡️ Анализ распределения и коллизий

Функция test_distribution_and_collisions оценивает качество распределения элементов по хэш-таблице и подсчитывает количество коллизий.

➡️ Измерение времени выполнения

Функция test_execution_time измеряет время, необходимое для хэширования набора элементов, что позволяет сравнить производительность разных хэш-функций.

➡️ Проверка чувствительности

Функция test_sensitivity проверяет, насколько хэш-функция чувствительна к небольшим изменениям во входных данных.

➡️ Заключение

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

👩‍💻👩‍💻 Итерируемый счетчик в Python

➡️ Что такое итерируемый счетчик?

Итерируемый счетчик в Python - это объект, который можно использовать в цикле for и других итерационных контекстах. Он позволяет последовательно получать значения, обычно числовые, в заданном диапазоне или по определенному правилу.

➡️ Реализация итерируемого счетчика

Давайте рассмотрим пример реализации простого итерируемого счетчика:

class IterableCounter:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.end:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

В этом примере:

- init инициализирует счетчик начальным и конечным значениями.
- iter возвращает сам объект, делая его итератором.
- next определяет логику получения следующего значения.

➡️ Использование итерируемого счетчика

Теперь мы можем использовать наш счетчик в цикле for:

counter = IterableCounter(1, 5)
for num in counter:
    print(num)

Этот код выведет числа от 1 до 5.

➡️ Преимущества итерируемого счетчика

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

➡️ Альтернативы

В Python есть встроенные альтернативы для простых случаев:

- range(): для последовательностей целых чисел.
- enumerate(): для нумерации элементов итерируемого объекта.

➡️ Заключение

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

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🔥🔥 Эффекты сообщений message_effect_id в Telegram Bot API

message_effect_id - это уникальный идентификатор, используемый в Telegram Bot API для определения конкретного визуального эффекта, который можно применить к сообщению. Эти эффекты представляют собой анимированные реакции, которые пользователи могут добавлять к сообщениям.

➡️ Основные характеристики message_effect_id:

Уникальность: Каждый эффект имеет свой уникальный числовой идентификатор.Формат: Идентификаторы представлены в виде строк, содержащих длинные числовые значения.Связь с эмодзи: Каждый message_effect_id соответствует определенному эмодзи, которое визуально представляет эффект.

➡️Примеры message_effect_id:

{
    '🔥': "5104841245755180586",
    '👍': "5107584321108051014",
    '👎': "5104858069142078462",
    '❤️': "5044134455711629726",
    '🎉': "5046509860389126442",
    '💩': "5046589136895476101"
}

➡️Использование в Telegram Bot API:

Применение эффектов: Боты могут использовать эти идентификаторы для добавления анимированных реакций к сообщениям.Интерактивность: Позволяет создавать более динамичные и интерактивные взаимодействия в чатах.Кастомизация: Разработчики могут выбирать конкретные эффекты для различных сценариев использования бота.

➡️ Значение для разработчиков:

Понимание и правильное использование message_effect_id позволяет разработчикам ботов создавать более привлекательные и интерактивные интерфейсы, улучшая пользовательский опыт в Telegram.

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻