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

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

✈️LineaPy — это библиотека для работы с временными рядами и анализа временных данных, которая помогает быстро перейти от создания прототипов к созданию надёжных конвейеров данных.


➡️Эта библиотека позволяет быстро решать типовые задачи анализа временных рядов без необходимости "изобретать велосипед". Она удобна для анализа временных данных в задачах прогнозирования, мониторинга, выявления сезонности, трендов и аномалий. Имеет интуитивный API и хорошую документацию.

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

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from lineapy import LineaPy

# Создаем синтетические данные
np.random.seed(42)
X = np.random.rand(100, 1) * 10  # 100 случайных точек в диапазоне от 0 до 10
y = 2.5 * X + np.random.randn(100, 1) * 2  # Линейная зависимость с шумом

# Преобразуем данные в DataFrame
data = pd.DataFrame(np.hstack((X, y)), columns=['X', 'y'])

# Создаем модель с помощью LineaPy
model = LineaPy()
model.fit(data['X'], data['y'])

# Предсказания
predictions = model.predict(data['X'])

# Визуализация
plt.scatter(data['X'], data['y'], color='blue', label='Данные')
plt.plot(data['X'], predictions, color='red', label='Предсказание')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Линейная Регрессия с LineaPy')
plt.legend()
plt.show()

⬆️Этот простой пример иллюстрирует, как можно использовать LineaPy для создания линейной модели и анализа данных.

🐍Pythoner

✈️Fugue — это мощный инструмент для обработки данных, который объединяет возможности Python и SQL. Она разработана для упрощения обработки данных в распределенных системах, таких как Apache Spark и Dask, и позволяет писать код, который будет работать как в локальном режиме, так и в распределенном.

➡️Основные возможеости:
💬Упрощение кода для обработки данных
💬Поддержка различных движков выполнения (Spark, Dask)
💬Поддержка SQL, что позволяет использованию знакомого синтаксиса для работы с данными

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

# Установка библиотеки
!pip install fugue

# Импорт необходимых модулей
from fugue import FugueEngine
from fugue.spark import SparkExecutionEngine

# Пример обработки данных
def process_data(df):
    return df.groupby("category").agg({"value": "sum"})

# Инициализация движка
engine = SparkExecutionEngine()

# Чтение данных
data = [
    {"category": "A", "value": 10},
    {"category": "B", "value": 20},
    {"category": "A", "value": 30},
]

# Обработка данных
result = engine.run(data, process_data)

# Вывод результата
print(result)

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

🐍Pythoner

➡️Монолитная архитектура

Монолитная архитектура представляет собой традиционный подход к разработке приложений, где все компоненты тесно связаны и работают как единое целое.

➕Преимущества:
💬Простота разработки и развертывания
💬Легкость в отладке и тестировании
💬Высокая производительность из-за отсутствия сетевых задержек между компонентами

❌Недостатки:
💬Сложность масштабирования отдельных компонентов
💬Затруднительное внедрение новых технологий
💬Риск "снежного кома" при росте сложности проекта

➡️Микросервисная архитектура

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

➕Преимущества:
💬Гибкость в выборе технологий для каждого сервиса
💬Легкость масштабирования отдельных компонентов
💬Возможность независимой разработки и развертывания сервисов

❌Недостатки:
💬Сложность в управлении и оркестрации множества сервисов
💬Повышенные требования к инфраструктуре
💬Потенциальные проблемы с производительностью из-за сетевых взаимодействий

🔎Что выбрать для вашего проекта?

Выбор архитектуры зависит от нескольких факторов:

➡️Выбирайте монолитную архитектуру, если:
💬У вас небольшой проект или стартап
💬Вам нужно быстро вывести продукт на рынок
💬У вас ограниченные ресурсы для разработки и поддержки

➡️Выбирайте микросервисную архитектуру, если:
💬У вас крупный проект с множеством функций
💬Вам нужна высокая масштабируемость и гибкость
💬У вас есть ресурсы для управления сложной инфраструктурой

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

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

🐍Pythoner

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

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 значительно упрощает реализацию классов, поддерживающих операции упорядочивания. Достаточно определить методы 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

🔎В следующем посте рассмотрим ещё несколько функций

🐍Pythoner

✅Продолжаем!

➡️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 помогает сохранить метаданные оригинальной функции при создании декораторов. Это особенно важно при использовании инструментов документации и отладки.

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__)   # Выведет: Приветствует пользователя по имени

🐍Pythoner

✈️В 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): динамическое создание классов на основе структуры базы данных.

🐍Pythoner

✈️В мире разработки программного обеспечения постоянно появляются новые тренды и подходы. Одним из таких трендов, набирающих популярность в последние годы, является функциональное программирование (ФП). Давайте разберемся, почему это происходит!

➡️Что такое функциональное программирование?

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

➡️Почему ФП становится популярнее?

💬Упрощение параллельного программирования: Отсутствие побочных эффектов делает код более предсказуемым и легким для распараллеливания.
💬Меньше багов: Неизменяемость данных и чистые функции снижают вероятность ошибок, связанных с состоянием программы.
💬Более читаемый код: ФП поощряет написание небольших, специализированных функций, что улучшает читаемость и поддерживаемость кода.
💬Легкость тестирования: Чистые функции легче тестировать, так как их поведение зависит только от входных данных.
💬Производительность: Некоторые функциональные концепции, такие как ленивые вычисления, могут повысить производительность программ.

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

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

🐍Pythoner

✈️Asyncio: ваш секретный ингредиент для высоких нагрузок

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

➡️Настройка asyncio: тюнинг вашего кода

💬Выбор правильного event loop. Для Linux-систем рекомендую uvloop – он может разогнать ваше приложение до космических скоростей:

import asyncio
import uvloop

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

💬Настройка пула потоков:

loop = asyncio.get_event_loop()
loop.set_default_executor(concurrent.futures.ThreadPoolExecutor(max_workers=10))

💬Семафоры — Они помогут контролировать конкурентность и избежать перегрузок:

sem = asyncio.Semaphore(10)

async def controlled_task(i):
    async with sem:
        # Ваш асинхронный код здесь
        await asyncio.sleep(1)
        print(f"Задача {i} выполнена!")

➡️Лайфхаки для покорения высот производительности

💬Замените requests на aiohttp для HTTP-запросов. Это как пересесть с велосипеда на реактивный самолет – скорость поразит ваше воображение!

💬Используйте aiomysql или asyncpg для работы с базами данных. Ваши запросы будут молниеносными, словно Усэйн Болт на стометровке!

💬Профилируйте код с помощью cProfile или yappi. Найдите узкие места и оптимизируйте их, как настоящий хирург производительности.

🔎Продвинутые техники

➡️Используйте асинхронные контекстные менеджеры для элегантной обработки ресурсов:

class AsyncContextManager:
    async def __aenter__(self):
        print("Entering the matrix...")
        await asyncio.sleep(1)
        return self

    async def __aexit__(self, exc_type, exc, tb):
        print("Exiting the matrix...")
        await asyncio.sleep(1)

async def main():
    async with AsyncContextManager() as manager:
        print("We're in!")

➡️Не забывайте про асинхронные генераторы – они могут творить настоящие чудеса в потоковой обработке данных:

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, 10):
        print(num)

➡️Заключение: ваш путь к асинхронному совершенству

Asyncio – это не просто библиотека, это образ мышления. Освоив его, вы сможете создавать приложения, которые будут работать быстрее, эффективнее и элегантнее. Помните: в мире асинхронного программирования нет ничего невозможного!

🐍Pythoner

Представьте, что ваш код – это оркестр в Мариинском театре. Каждый инструмент (поток или корутина) играет свою партию. А вы – дирижёр, который должен убедиться, что все звучит гармонично. Вот только как это сделать, когда все играют одновременно?

➡️1. Изоляция – ключ к успеху

Первое правило тестирования параллельного кода: изолируйте тесты! Каждый тест должен быть как отдельная комната в звукоизолированной студии. Используйте моки и стабы, чтобы симулировать внешние зависимости. Вот пример с использованием unittest.mock:

from unittest.mock import patch
import asyncio

async def fetch_data(url):
    # Реальный запрос к API
    ...

@patch('your_module.fetch_data')
async def test_process_data(mock_fetch):
    mock_fetch.return_value = {'key': 'value'}
    result = await process_data('http://api.example.com')
    assert result == 'processed value'

⬆️Мы изолировали тест от реального API. Теперь он быстрый, как Усэйн Болт, и предсказуемый, как восход солнца!

➡️2. Детерминизм – ваш лучший друг

Асинхронный код может быть непредсказуемым, как погода в Питере. Но ваши тесты должны быть стабильными, как гранитная набережная. Используйте семафоры, события и другие примитивы синхронизации, чтобы контролировать порядок выполнения. Вот пример с использованием asyncio.Event:

import asyncio

async def test_order_of_execution():
    event = asyncio.Event()
    results = []

    async def task1():
        await event.wait()
        results.append(1)

    async def task2():
        results.append(2)
        event.set()

    await asyncio.gather(task1(), task2())
    assert results == [2, 1]

⬆️Этот тест всегда будет проходить, даже если вы запустите его на компьютере, работающем на картофельной батарейке!

➡️3. Таймауты – не просто для пиццы

Установка таймаутов в тестах – это как страховка. Вы надеетесь, что она не понадобится, но лучше иметь ее под рукой. Вот как можно использовать таймауты в pytest:

import pytest
import asyncio

@pytest.mark.asyncio
async def test_long_running_task():
    with pytest.raises(asyncio.TimeoutError):
        await asyncio.wait_for(never_ending_task(), timeout=1.0)

⬆️Этот тест убедится, что ваша функция не зависнет, как старый Windows при запуске Crysis!

➡️4. Асинхронные фикстуры – ваш секретный козырь

В мире async/await фикстуры тоже должны быть асинхронными. Используйте async fixtures в pytest для подготовки и очистки тестового окружения. Вот пример:

import pytest
import asyncio

@pytest.fixture
async def database():
    db = await create_database_connection()
    yield db
    await db.close()

@pytest.mark.asyncio
async def test_database_query(database):
    result = await database.fetch('SELECT * FROM users')
    assert len(result) > 0

⬆️Эта фикстура – как заботливая мама, которая готовит завтрак перед школой и убирает посуду после. Только вместо завтрака у нас база данных!

➡️5. Параллельное выполнение тестов – двойная выгода

Запуск тестов параллельно не только ускоряет процесс, но и помогает выявить проблемы с состоянием гонки. Используйте pytest-xdist, но будьте осторожны: убедитесь, что ваши тесты действительно независимы друг от друга. Вот команда для запуска:

pytest -n auto your_test_file.py

⬆️Это как устроить гонки Формулы-1 для ваших тестов. Победит самый быстрый и надежный код!

🐍Pythoner

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

➡️Основы Docker

💬Образы (Images): Шаблоны для создания контейнеров
💬Контейнеры: Запущенные экземпляры образов
💬Dockerfile: Инструкции для сборки образа
💬Docker Hub: Репозиторий для хранения и обмена образами

➡️Базовые команды Docker:

# Сборка образа
docker build -t my-image .

# Запуск контейнера
docker run -d --name my-container my-image

# Просмотр запущенных контейнеров
docker ps

# Остановка контейнера
docker stop my-container

🔎Продвинутые техники

➡️1. Docker Compose

Docker Compose позволяет определять и запускать многоконтейнерные приложения. Пример docker-compose.yml файла:

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"

➡️2. Docker Networking

Docker предоставляет мощные возможности для создания сетей между контейнерами:

💬Bridge networks: Стандартная сеть для контейнеров на одном хосте
💬Overlay networks: Для связи контейнеров на разных хостах
💬Host networking: Использование сети хоста напрямую

➡️3. Docker Volumes

Volumes используются для хранения данных вне контейнеров:

# Создание volume
docker volume create my-vol

# Использование volume при запуске контейнера
docker run -v my-vol:/app/data my-image

➡️4. Docker Swarm

Docker Swarm - это инструмент для оркестрации контейнеров, позволяющий управлять кластером Docker-хостов:

💬Инициализация Swarm: docker swarm init
💬Развертывание сервиса: docker service create
💬Масштабирование: docker service scale

➡️Лучшие практики

💬Используйте многоэтапные сборки для оптимизации образов
💬Минимизируйте количество слоев в Dockerfile
💬Используйте .dockerignore для исключения ненужных файлов
💬Регулярно обновляйте базовые образы для безопасности

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

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

🐍Pythoner