Сделали для подписчиков наших каналов по Python небольшой розыгрыш звёзд😘

1 ноября в 18 часов по мск, 5 победителей получат по 100 звёзд, которые можно тратить в нашем и других каналах, дарить подарки и другое, удачи!

P.S. говорят если переслать этот розыгрыш друзьям, то шанс увеличится.

😈 IT memer

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.

🐍Pythoner

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

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

🐍Pythoner

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

➡️Применение

С помощью Manim можно создавать как простые анимации, так и сложные сцены с множеством объектов и эффектов. Библиотека предоставляет обширные возможности по работе с графикой, анимацией и текстом.

➡️Пример:

from manim import *

class SquareNumber(Scene):
    def construct(self):
        # Создаем квадрат и текст
        square = Square(side_length=2)
        number = MathTex("0").scale(2)

        # Центрируем квадрат и текст
        square.move_to(ORIGIN)
        number.next_to(square, DOWN)

        # Добавляем квадрат и текст на экран
        self.play(Create(square), Write(number))
        self.wait(1)

        # Изменяем текст на 1
        self.play(Transform(number, MathTex("1").scale(2)))
        self.wait(1)

        # Изменяем текст на 4 и меняем размер квадрата
        self.play(Transform(number, MathTex("4").scale(2)),
                  square.animate.scale(2))
        self.wait(1)

        # Изменяем текст на 9 и меняем размер квадрата
        self.play(Transform(number, MathTex("9").scale(2)),
                  square.animate.scale(3))
        self.wait(1)

        # Завершаем сцену
        self.play(FadeOut(square), FadeOut(number))

# Для запуска сцены используйте следующую команду в терминале
# manim -pql имя_файла.py SquareNumber

⬆️Чтобы запустить данный код и увидеть анимацию, сохраните его в файл, например, square_number.py, и выполните указанную команду в терминале.

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

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

🐍Pythoner

✈️Хэш-функции играют важную роль в компьютерных науках, особенно в структурах данных и криптографии. В этой статье мы рассмотрим различные типы хэш-функций, реализованные на 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

🐍Pythoner

✈️А в этой части рассмотрим тестирование хэш-функций

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

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

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

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

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

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

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

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

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

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

🐍Pythoner

Куча (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):
        # Реализация метода опускания элемента

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

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

🐍Pythoner

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

➡️Пример — жадный алгоритм для дробной задачи о рюкзаке на 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)

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

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

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

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

🐍Pythoner

✈️Лямбда-функции в 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 — мощный инструмент для создания кратких, анонимных функций. При правильном использовании они могут значительно улучшить читаемость и эффективность кода. Однако важно помнить об их ограничениях и использовать их разумно, в соответствии с лучшими практиками программирования.

🐍Pythoner

➡️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=<your key here>
mentat <paths to files or directories>

➡️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

🐍Pythoner

➡️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)

🐍Pythoner

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

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

Представьте обычный генератор, но на стероидах. Асинхронный генератор — это функция, которая использует 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, которое возвращает данные постранично, асинхронный генератор может абстрагировать логику пагинации, предоставляя удобный интерфейс для работы с данными.

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

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

🐍Pythoner

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

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

Помните, как вы впервые узнали о декораторах? Наверняка это было что-то вроде @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

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

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

🐍Pythoner

➡️Зачем вообще париться с памятью в 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)

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

🐍Pythoner