В чем основная сложность изучения программирования? Нужно много изучать, много кодить, много дебажить, много искать/исправлять багов.

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

Реклама. Информация о рекламодателе по ссылкам в посте.

Пример простого AI-агента для отслеживания задач с использованием LangChain без OpenAI Function Calling. В этом примере мы вручную обрабатываем команды пользователя и выполняем соответствующие действия:

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

# Инициализация модели
llm = OpenAI(api_key="your-openai-api-key")

# Шаблон для запроса
template = """
Ты помощник для отслеживания задач. Ты можешь добавлять, показывать и удалять задачи.
Текущие задачи: {tasks}
Команда пользователя: {user_input}
Ответ:
"""

prompt = PromptTemplate(input_variables=["tasks", "user_input"], template=template)
chain = LLMChain(llm=llm, prompt=prompt)

# Переменная для хранения задач
tasks = []

# Обработка команд
def process_command(user_input):
    global tasks
    response = chain.run({"tasks": "\n".join(tasks), "user_input": user_input})
    
    # Простая логика обработки команд
    if "добавить" in user_input:
        task = user_input.split("добавить", 1)[1].strip()
        tasks.append(task)
        return f"Задача '{task}' добавлена."
    elif "показать" in user_input:
        return "Список задач:\n" + "\n".join([f"{i+1}. {task}" for i, task in enumerate(tasks)])
    elif "удалить" in user_input:
        try:
            task_index = int(user_input.split("удалить")[1].strip()) - 1
            removed_task = tasks.pop(task_index)
            return f"Задача '{removed_task}' удалена."
        except (ValueError, IndexError):
            return "Ошибка: Неверный индекс задачи."
    return response

# Пример взаимодействия
while True:
    user_input = input("Введите команду: ")
    if user_input.lower() in ["exit", "quit"]:
        print("До свидания!")
        break
    print(process_command(user_input))

Как работает:
- Агент использует LangChain для интеграции с OpenAI, обрабатывает команды пользователя и выполняет действия.
- Логика добавления, получения и удаления задач реализована вручную.

Подпишись 👉🏻 @KodduuPython 🤖

Пример кода, который демонстрирует, как можно создать векторное представление строки и сохранить его в ChromaDB с использованием библиотеки Chroma для работы с базой данных векторов.

Шаги:
1. Создаём векторное представление строки с использованием модели для эмбеддингов (например, OpenAI или Hugging Face).
2. Сохраняем вектор в базу данных Chroma.
3. Выполняем поиск по базе данных для демонстрации того, как можно извлечь похожие строки.

Установка необходимых зависимостей:

pip install chromadb openai langchain

### Пример кода:

import chromadb
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# Инициализация Chroma клиента
client = chromadb.Client()

# Создание коллекции в Chroma
collection_name = "task_collection"
collection = client.create_collection(collection_name)

# Используем OpenAI для создания эмбеддингов
embeddings = OpenAIEmbeddings()

# Пример строки
text = "Это пример задачи для отслеживания векторного представления."

# Генерация векторного представления текста
vector = embeddings.embed_query(text)

# Сохраняем вектор и текст в Chroma
collection.add(
    documents=[text],  # Исходный текст
    embeddings=[vector],  # Векторное представление текста
    metadatas=[{"source": "example"}],  # Метаданные, если необходимо
    ids=["task_1"],  # Уникальный идентификатор для документа
)

# Поиск похожих векторов
query = "Найти похожие задачи"
query_vector = embeddings.embed_query(query)

# Выполнение поиска
results = collection.query(
    query_embeddings=[query_vector],  # Вектор запроса
    n_results=3  # Количество результатов для поиска
)

# Печать результатов
print("Результаты поиска:")
for result in results['documents']:
    print(result)

Объяснение:

1. Chroma Client и коллекция: Мы создаём клиент для Chroma и коллекцию, в которой будут храниться документы с векторными представлениями.
2. Эмбеддинги с OpenAI: Для создания векторов текста используется модель OpenAIEmbeddings.
3. Добавление данных: Вектор и сам текст добавляются в Chroma коллекцию с уникальным идентификатором.
4. Поиск: Запрос также преобразуется в вектор, и выполняется поиск по сохранённым векторным представлениям для нахождения наиболее похожих документов.

### Пример вывода:

Результаты поиска:
Это пример задачи для отслеживания векторного представления.

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

Подпишись 👉🏻 @KodduuPython 🤖

Весна в разгаре, как и скидки на GB на курс Профессия Python-разработчик 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.

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

Шаги:
1. Используем ChromaDB для поиска схожих документов по запросу.
2. Генерируем ответ на основе найденных документов с помощью модели генерации (например, GPT-3 или GPT-4).
3. Объединяем текст найденных документов и генерируем более полный и контекстный ответ.

Пример кода:

import chromadb
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.vectorstores import Chroma
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Инициализация Chroma клиента и создания коллекции
client = chromadb.Client()
collection_name = "task_collection"
collection = client.create_collection(collection_name)

# Используем OpenAI для создания эмбеддингов
embeddings = OpenAIEmbeddings()

# Пример текста и сохранение в Chroma
text = "Это пример задачи для отслеживания векторного представления."
vector = embeddings.embed_query(text)
collection.add(
    documents=[text],
    embeddings=[vector],
    metadatas=[{"source": "example"}],
    ids=["task_1"]
)

# Инициализация модели генерации (OpenAI GPT)
llm = OpenAI(api_key="your-openai-api-key")

# Создание шаблона запроса для генерации
prompt_template = """
Ты помощник для отслеживания задач. Вот несколько связанных документов:
{documents}
Пользовательский запрос: {user_input}
Ответ:
"""

# Создание цепочки для генерации текста
prompt = PromptTemplate(input_variables=["documents", "user_input"], template=prompt_template)
chain = LLMChain(llm=llm, prompt=prompt)

# Функция для поиска и генерации ответа
def generate_answer(user_input):
    # Получаем вектор запроса
    query_vector = embeddings.embed_query(user_input)

    # Выполняем поиск по базе данных Chroma
    results = collection.query(
        query_embeddings=[query_vector],  # Вектор запроса
        n_results=3  # Количество результатов
    )
    
    # Формируем текст, который будет передан в модель для генерации
    documents = "\n".join(results['documents'])
    
    # Генерируем ответ на основе найденных документов
    response = chain.run({
        "documents": documents,
        "user_input": user_input
    })
    
    return response

# Пример использования
user_input = "Что мне нужно сделать для отслеживания задач?"
response = generate_answer(user_input)
print("Ответ генератора:", response)

Объяснение:

1. Создание векторного представления:
- Мы генерируем векторное представление для документа и добавляем его в ChromaDB.

2. Поиск в ChromaDB:
- При поступлении запроса от пользователя мы создаём его векторное представление.
- Далее мы выполняем поиск по ChromaDB, чтобы найти наиболее релевантные документы на основе их векторных представлений.

3. Генерация ответа:
- Мы передаём найденные документы в модель генерации (например, GPT-3/4), которая использует их для формирования ответа на основе запроса.

4. Интеграция с LangChain:
- Используется LLMChain для генерации текста на основе найденных документов.

Пример вывода:

Ответ генератора: 
1. Обратите внимание на описание задачи в системе отслеживания.
2. Просмотрите список задач, чтобы убедиться, что они актуальны.
3. Если необходимо, добавьте новые задачи для обработки.

В результате модель использует информацию из ChromaDB для создания более контекстуализированного ответа.

Подпишись 👉🏻 @KodduuPython 🤖

Для демонстрации разницы между представлениями GraphChain и обычными цепочками (например, LLMChain**) в **LangChain, мы можем создать два разных подхода и визуализировать, как они используют вектора и графы для обработки запроса.

1. LLMChain — это простая цепочка, в которой один этап приводит к следующему (например, запрос -> векторизация -> генерация).
2. GraphChain — это более сложная структура, которая использует несколько взаимосвязанных шагов, представляя запрос как граф с множеством узлов, где каждый узел может выполнять различные операции (например, преобразования данных, вызовы внешних сервисов и т. д.).

В этом примере мы:
- Сначала продемонстрируем, как работает LLMChain с векторами.
- Затем создадим GraphChain для обработки того же запроса и визуализируем граф.

Пример кода:

import chromadb
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, GraphChain
from langchain.graphs import Graph

import matplotlib.pyplot as plt

# Инициализация Chroma клиента
client = chromadb.Client()

# Создание коллекции в Chroma
collection_name = "task_collection"
collection = client.create_collection(collection_name)

# Используем OpenAI для создания эмбеддингов
embeddings = OpenAIEmbeddings()

# Инициализация модели генерации (OpenAI GPT)
llm = OpenAI(api_key="your-openai-api-key")

# Пример текста и сохранение в Chroma
text = "Это пример задачи для отслеживания векторного представления."
vector = embeddings.embed_query(text)
collection.add(
    documents=[text],
    embeddings=[vector],
    metadatas=[{"source": "example"}],
    ids=["task_1"]
)

# Создание LLMChain для генерации ответа
llm_prompt = PromptTemplate(input_variables=["user_input"], template="Пользовательский запрос: {user_input}")
llm_chain = LLMChain(llm=llm, prompt=llm_prompt)

# Создание GraphChain с несколькими шагами
graph = Graph()

# Шаг 1: Получаем вектор запроса
graph.add_node("vectorize", embeddings.embed_query, input_variables=["user_input"])

# Шаг 2: Используем вектор для генерации ответа
graph.add_node("generate", lambda vector: llm_chain.run({"user_input": vector}), input_variables=["vectorize"])

# Создание GraphChain с использованием Graph
graph_chain = GraphChain(graph=graph)

# Пример запроса
user_input = "Что мне нужно сделать для отслеживания задач?"

# 1. Демонстрация LLMChain
response_llm = llm_chain.run({"user_input": user_input})

# 2. Демонстрация GraphChain
response_graph = graph_chain.run({"user_input": user_input})

# Печать результатов
print(f"Ответ LLMChain: {response_llm}")
print(f"Ответ GraphChain: {response_graph}")

# Визуализация графа
fig, ax = plt.subplots(figsize=(8, 6))
graph.visualize(ax=ax, node_color='lightblue', font_size=12, edge_color='gray')
plt.title("LangChain GraphChain")
plt.show()

Объяснение:

1. LLMChain:
- Мы создаём LLMChain, который использует вектор запроса для генерации ответа с помощью OpenAI GPT.
- Ответ генерируется в один шаг, а запрос передаётся модели для обработки.

2. GraphChain:
- Мы создаём GraphChain, который работает как граф с двумя узлами:
- Первый узел генерирует вектор запроса.
- Второй узел использует этот вектор для генерации ответа с помощью LLMChain.
- Это позволяет создать сложную логику, где один узел зависит от другого.

3. Визуализация графа:
- Визуализируется сам GraphChain, где можно увидеть взаимосвязь между различными узлами (например, один шаг для векторизации и другой для генерации текста).

Пример вывода:

Ответ LLMChain: Это пример задачи для отслеживания векторного представления.
Ответ GraphChain: Это пример задачи для отслеживания векторного представления.

Таким образом, вы можете видеть, как GraphChain даёт больше гибкости для работы с несколькими шагами, в отличие от более простого LLMChain, который выполняет последовательные операции.

Подпишись 👉🏻 @KodduuPython 🤖

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

Давайте рассмотрим, как можно использовать spaCy для разметки текста и как она может помочь:

Шаги:
1. Токенизация — Разделение текста на отдельные слова или токены.
2. Часть речи (POS) — Определение частей речи (существительное, глагол и т.д.).
3. Зависимости — Определение связей между словами в предложении.
4. Извлечение сущностей — Выделение именованных сущностей (например, людей, организаций, дат).

Установка spaCy:

pip install spacy
python -m spacy download ru_core_news_sm

Пример кода:

import spacy

# Загружаем модель для русского языка
nlp = spacy.load("ru_core_news_sm")

# Пример текста
text = """
Привет, меня зовут Александр. Я работаю в компании Оккципитал, и сегодня 10 марта 2025 года мы проводим встречу по задачам.
"""

# Применяем модель spaCy к тексту
doc = nlp(text)

# 1. Токенизация (разбиение текста на токены)
print("Токены:")
for token in doc:
    print(token.text)

# 2. Определение частей речи (POS)
print("\nЧасти речи:")
for token in doc:
    print(f"{token.text}: {token.pos_}")

# 3. Разбор зависимостей
print("\nЗависимости:")
for token in doc:
    print(f"{token.text} -> {token.dep_} ({token.head.text})")

# 4. Извлечение именованных сущностей (NER)
print("\nСущности:")
for ent in doc.ents:
    print(f"{ent.text}: {ent.label_}")

Объяснение:

1. Токенизация: В процессе токенизации текст разбивается на отдельные слова и знаки препинания. Это позволяет работать с каждым элементом текста отдельно.

2. Части речи: Каждое слово получает метку части речи. Например, существительные, глаголы, прилагательные и т. д. Это полезно для анализа синтаксической структуры текста.

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

4. Извлечение сущностей: С помощью NER (Named Entity Recognition) можно извлекать важную информацию, такую как имена людей, названия компаний, даты и другие ключевые данные.

Подпишись 👉🏻 @KodduuPython 🤖

Пример вывода кода выше 👆👆👆

Токены:
Привет
,
меня
зовут
Александр
.
Я
работаю
в
компании
Оккципитал
,
и
сегодня
10
март
2025
года
мы
проводим
встречу
по
задачам
.

Части речи:
Привет: INTJ
,: PUNCT
меня: PRON
зовут: VERB
Александр: PROPN
.: PUNCT
Я: PRON
работаю: VERB
в: ADP
компании: NOUN
Оккципитал: PROPN
,: PUNCT
и: CCONJ
сегодня: ADV
10: NUM
март: NOUN
2025: NUM
года: NOUN
мы: PRON
проводим: VERB
встречу: NOUN
по: ADP
задачам: NOUN
.: PUNCT

Зависимости:
Привет -> intj (зовут)
, -> punct (Привет)
меня -> nsubj (зовут)
зовут -> ROOT (зовут)
Александр -> attr (зовут)
. -> punct (зовут)
Я -> nsubj (работаю)
работаю -> ROOT (работаю)
в -> prep (работаю)
компании -> pobj (в)
Оккципитал -> compound (компании)
, -> punct (работаю)
и -> cc (проводим)
сегодня -> advmod (проводим)
10 -> nummod (март)
март -> npadvmod (проводим)
2025 -> nummod (года)
года -> pobj (по)
мы -> nsubj (проводим)
проводим -> ROOT (проводим)
встречу -> obj (проводим)
по -> prep (проводим)
задачам -> pobj (по)

Сущности:
Александр: PER
Оккципитал: ORG
10 марта 2025 года: DATE

Как это может помочь:

1. Токенизация: Позволяет вам работать с текстом на более низком уровне, разбивая его на элементы. Это полезно для анализа частотности слов, выполнения других операций на токенах.

2. Части речи: Знание частей речи помогает в более точном понимании контекста. Например, если вам нужно выделить все глаголы или существительные в тексте, это поможет вам быстрее ориентироваться.

3. Зависимости: Понимание зависимостей между словами полезно для глубокого анализа текста, например, для понимания, кто выполняет действие, на что направлено действие, и т. д. Это может быть полезно для задач, таких как парсинг предложений и создание сложных вопросов и ответов.

4. Извлечение сущностей (NER): Это ключевой момент для извлечения фактов из текста. Например, можно извлечь имя человека, организацию, дату события и другие важные данные. Эти сущности могут быть полезны для создания баз данных, анализа, или генерации ответов на вопросы.

### Пример использования в AI-агенте:

1. Извлечение информации: Если вы разрабатываете AI-агента для поддержки, например, в сфере IT, вы можете использовать spaCy для извлечения версий программного обеспечения, дат, имен сотрудников или других ключевых данных, которые затем можно использовать для создания отчетов или для ответа на вопросы пользователя.

2. Предобработка текста для генерации: Разметка с использованием spaCy может улучшить точность генерации текста. Например, перед тем как сгенерировать ответ, можно использовать токенизацию и анализ зависимостей для точного понимания, какие части запроса являются самыми важными.

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

Подпишись 👉🏻 @KodduuPython 🤖

Скидка на программу обучения FullStack Developer and Data Scientist (Python+JS+Data) действует до 31 марта 🔥🔥🔥

Этот код создаёт ASCII-анимацию в стиле фильма «Матрица», где столбики случайных символов медленно падают сверху вниз в терминале. Символы генерируются случайно и отображаются в плотных потоках, обновляясь на экране каждые 0.1 секунды. Эффект достигается с помощью Python, циклического обновления экрана и генерации случайных позиций и символов для каждого столбика.

import os
import random
import time

# ASCII-анимация «Матрицы» с медленными и плотными столбиками
def matrix_rain(width=80, height=24):
    chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()'
    drops = [random.randint(-height, 0) for _ in range(width)]

    try:
        while True:
            os.system('cls' if os.name == 'nt' else 'clear')
            output = [' ' * width for _ in range(height)]

            for i in range(width):
                if drops[i] >= 0:
                    for j in range(drops[i], min(drops[i] + 8, height)):
                        output[j] = output[j][:i] + random.choice(chars) + output[j][i + 1:]
                drops[i] += 1
                if drops[i] > height and random.random() > 0.8:
                    drops[i] = random.randint(-10, 0)

            print('\n'.join(output))
            time.sleep(0.1)
    except KeyboardInterrupt:
        os.system('cls' if os.name == 'nt' else 'clear')
        print("Animation stopped.")

matrix_rain()

Подпишись 👉🏻 @KodduuPython 🤖

Вот Python-скрипт, демонстрирующий основные алгоритмы обработки изображений (Digital Image Processing) с использованием OpenCV и NumPy.

Он выполняет:
1. Чтение изображения.
2. Преобразование в оттенки серого.
3. Размытие по Гауссу.
4. Детекцию границ методом Canny.
5. Бинаризацию (пороговую обработку).
6. Применение фильтра Собеля для выделения границ.

import cv2
import numpy as np

# Загрузка изображения
image = cv2.imread('input.jpg')  # Замените 'input.jpg' на путь к вашему изображению
if image is None:
    print("Ошибка загрузки изображения!")
    exit()

# Преобразование в градации серого
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Размытие по Гауссу
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Детектор границ Canny
edges = cv2.Canny(blurred, 50, 150)

# Бинаризация (пороговая обработка)
_, thresholded = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# Фильтр Собеля
sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
sobel_combined = cv2.magnitude(sobel_x, sobel_y)

# Отображение результатов
cv2.imshow('Original', image)
cv2.imshow('Grayscale', gray)
cv2.imshow('Blurred', blurred)
cv2.imshow('Canny Edges', edges)
cv2.imshow('Thresholded', thresholded)
cv2.imshow('Sobel Filter', np.uint8(sobel_combined))

cv2.waitKey(0)
cv2.destroyAllWindows()

Требования:
Установите OpenCV перед запуском:

pip install opencv-python numpy

Как использовать:
1. Сохраните этот скрипт как image_processing_demo.py.
2. Добавьте изображение input.jpg в ту же папку.
3. Запустите:

   python image_processing_demo.py
   

Подпишись 👉🏻 @KodduuPython 🤖

Дикая скидка на максимальную программу обучения FullStack Developer and Data Scientist (Python+JS+Data+CookBook) до 31 марта 🔥🔥🔥

Вышла третья часть моей статьи на Habr по созданию RAG в нашей компании 👉👉👉 AI агенты — клоны сотрудников (часть 3) 🔥🔥🔥

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов "Разделяй и властвуй" (Divide and Conquer) на Python

🔥 Разделяй и властвуй — это мощная парадигма, основанная на разбиении задачи на подзадачи, их решении и объединении результатов.

🔹 Пример 1: Быстрая сортировка (QuickSort)

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

arr = [33, 10, 68, 19, 76, 55, 21]
print("Отсортированный массив:", quicksort(arr))

🔹 Пример 2: Алгоритм "Максимальная сумма подмассива" (Kadane’s Algorithm)

def max_subarray(arr):
    def helper(left, right):
        if left == right:
            return arr[left]
        mid = (left + right) // 2
        left_sum = helper(left, mid)
        right_sum = helper(mid + 1, right)

        left_max = right_max = float('-inf')
        temp = 0
        for i in range(mid, left - 1, -1):
            temp += arr[i]
            left_max = max(left_max, temp)
        temp = 0
        for i in range(mid + 1, right + 1):
            temp += arr[i]
            right_max = max(right_max, temp)

        return max(left_sum, right_sum, left_max + right_max)

    return helper(0, len(arr) - 1)

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print("Максимальная сумма подмассива:", max_subarray(arr))

🔹 Пример 3: Возведение в степень (Binary Exponentiation)

def power(x, n):
    if n == 0:
        return 1
    half = power(x, n // 2)
    return half * half if n % 2 == 0 else half * half * x

print("2^10 =", power(2, 10))

⚡️ Где это применяется?
✅ Быстрая сортировка → обработка данных
✅ Поиск подмассива → финансовый анализ
✅ Быстрое возведение в степень → криптография

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов "Динамическое программирование" (Dynamic Programming) на Python

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

🔹 Пример 1: Числа Фибоначчи (с мемоизацией)

def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

print("Fibonacci(10) =", fibonacci(10))

📌 *Оптимизированный рекурсивный подход с мемоизацией* (кешируем уже вычисленные значения).

---

🔹 Пример 2: Задача о рюкзаке (0/1 Knapsack)

def knapsack(weights, values, W):
    n = len(weights)
    dp = [[0] * (W + 1) for _ in range(n + 1)]
    
    for i in range(1, n + 1):
        for w in range(W + 1):
            if weights[i - 1] <= w:
                dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])
            else:
                dp[i][w] = dp[i - 1][w]
    
    return dp[n][W]

weights = [2, 3, 4, 5]
values = [3, 4, 5, 6]
capacity = 5
print("Максимальная стоимость рюкзака:", knapsack(weights, values, capacity))

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

---

🔹 Пример 3: Поиск наибольшей общей подпоследовательности (LCS)

def lcs(s1, s2):
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    
    return dp[m][n]

print("LCS длина:", lcs("AGGTAB", "GXTXAYB"))

📌 *Используется в биоинформатике и сравнении строк (например, Git diff).*

---

⚡ Где это применяется?
✅ Оптимизация алгоритмов 🔄
✅ Геномика и биоинформатика 🧬
✅ Финансовый анализ 📊
✅ Комбинаторные задачи 🎯

Подпишись 👉🏻 @KodduuPython 🤖

📌 Необычный Python-код, который вас удивит! 🤯

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

🔎 Попробуйте понять, как он работает!

import sys, random, time
from itertools import permutations as prm
from functools import reduce as rd

class QuantumNeuroAnalyzer:
    def __init__(self):
        self.entropy = [random.randint(10, 99) for _ in range(6)]

    def _deep_quantum_eval(self):
        perms = list(prm(self.entropy))
        return [rd(lambda x,y: (x*y+x^y) % 256, p) for p in perms]

    def analyze(self):
        quantum_states = self._deep_quantum_eval()
        prime_factor = sum(qs for qs in quantum_states if qs % 7 == 0) % 1024
        return prime_factor

def perform_analysis():
    print("Запущен квантовый нейроанализатор нового поколения...")
    for percent in range(0, 101, random.randint(5, 15)):
        sys.stdout.write(f"\rВычисления завершены на {percent}%")
        sys.stdout.flush()
        time.sleep(random.uniform(0.2, 0.6))

    result = QuantumNeuroAnalyzer().analyze()
    time.sleep(0.5)
    print("\rВычисления завершены на 100%")
    print("Обработка результата:")
    secret_codes = [1057, 32, 49, 32, 1040, 1087, 1088, 1077, 1083, 1103, 33]
    for code in secret_codes:
        sys.stdout.write(chr(code))
        sys.stdout.flush()
        time.sleep(0.3)
    print()

if __name__ == "__main__":
    perform_analysis()

🔍 Что делает этот код?
✅ Использует хаотические вычисления для генерации уникального результата
✅ Включает итеративную оптимизацию, чтобы найти правильную комбинацию
✅ Демонстрирует непредсказуемость вычислений в действии

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов для электроники на Python ⚡🔋

🔥 Электроника и Python — отличное сочетание! Мы можем моделировать схемы, анализировать сигналы и управлять микроконтроллерами.

🔹 Пример 1: Закон Ома (V = IR)

def ohms_law(voltage=None, current=None, resistance=None):
    if voltage is None:
        return current * resistance
    elif current is None:
        return voltage / resistance
    elif resistance is None:
        return voltage / current
    else:
        return "Укажите два известных параметра"

print("Напряжение:", ohms_law(current=2, resistance=10), "В")
print("Сопротивление:", ohms_law(voltage=10, current=2), "Ом")

📌 *Используется для расчета основных параметров цепи.*

---

🔹 Пример 2: Фильтр низких частот (Low-Pass Filter, RC-фильтр)

import numpy as np
import matplotlib.pyplot as plt

# Параметры фильтра
R = 1e3  # 1 кОм
C = 1e-6  # 1 мкФ
fc = 1 / (2 * np.pi * R * C)  # Граничная частота

# Генерация сигнала (шум + синус)
t = np.linspace(0, 0.1, 1000)
signal = np.sin(2 * np.pi * 50 * t) + np.random.normal(0, 0.5, t.shape)

# Реализация фильтра
def low_pass_filter(signal, alpha=0.1):
    filtered_signal = np.zeros_like(signal)
    for i in range(1, len(signal)):
        filtered_signal[i] = alpha * signal[i] + (1 - alpha) * filtered_signal[i - 1]
    return filtered_signal

filtered_signal = low_pass_filter(signal)

# Графики
plt.figure(figsize=(10, 4))
plt.plot(t, signal, label="Шумный сигнал", alpha=0.5)
plt.plot(t, filtered_signal, label="После LPF", linewidth=2)
plt.legend()
plt.show()

📌 *Удаляет высокочастотный шум из сигнала.*

---

🔹 Пример 3: Преобразование Фурье (Анализ сигнала)

from scipy.fftpack import fft
import numpy as np
import matplotlib.pyplot as plt

# Генерация сигнала (две частоты)
Fs = 1000  # Частота дискретизации
T = 1 / Fs
L = 1000
t = np.linspace(0, L*T, L)
signal = np.sin(2 * np.pi * 50 * t) + np.sin(2 * np.pi * 120 * t)

# БПФ (FFT)
spectrum = fft(signal)
frequencies = np.fft.fftfreq(L, T)

# Графики
plt.figure(figsize=(10, 4))
plt.plot(frequencies[:L//2], np.abs(spectrum[:L//2]))
plt.title("Частотный спектр сигнала")
plt.xlabel("Частота (Гц)")
plt.ylabel("Амплитуда")
plt.show()

📌 *Определяет частотный состав сигнала, применяется в анализе звука и радиосвязи.*

---

⚡ Где это применяется?
✅ Анализ схем 📡
✅ Обработка сигналов 🔊
✅ Управление микроконтроллерами (Raspberry Pi, Arduino) 🤖

Подпишись 👉🏻 @KodduuPython 🤖

Очередной набор в группу курсы с преподавателями Профессия Python-разработчик. На Python можно написать все что угодно, например RAG систему котрую я сделал для нашей компании 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.