🔥 Распродажа на Stepik закончится 4 декабря в 23:59 🏃🏃‍♀️

👉 Самое время пройти Python: самый быстрый курс 🧐

👉 Или окунутся в мир Data Science на курсе Python Data Science: самый быстрый курс 🤓

👉 Быстро выучить JS на курсу JavaScript: самый быстрый курс 😎

👉 И наконец узнать все сразу в программе курсов Junior Python Developer и Data Scientist +интервью тест 🧑‍🎓

КУПИТЬ КУРСЫ МОЖНО ЗА СЧЕТ РАБОТАДАТЕЛЯ 📌📌📌

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

🚀 Поиск кратчайшего пути с использованием алгоритма A*

from heapq import heappop, heappush

def heuristic(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def a_star_search(graph, start, goal):
    open_set = []
    heappush(open_set, (0, start))
    came_from = {}
    g_score = {start: 0}
    f_score = {start: heuristic(start, goal)}

    while open_set:
        _, current = heappop(open_set)

        if current == goal:
            return reconstruct_path(came_from, current)

        for neighbor in graph.get(current, []):
            tentative_g_score = g_score + graph
            if tentative_g_score < g_score.get(neighbor, float('inf')):
                came_from = current
                g_score = tentative_g_score
                f_score = tentative_g_score + heuristic(neighbor, goal)
                if neighbor not in open_set:
                    heappush(open_set, (f_score, neighbor))

    return None

def reconstruct_path(came_from, current):
    total_path = 
    while current in came_from:
        current = came_from
        total_path.append(current)
    return total_path[::-1]

# Пример использования
graph = {
    (0, 0): {(1, 0): 1, (0, 1): 1},
    (1, 0): {(0, 0): 1, (1, 1): 1, (2, 0): 1},
    (0, 1): {(0, 0): 1, (1, 1): 1},
    (1, 1): {(1, 0): 1, (0, 1): 1, (2, 1): 1},
    (2, 0): {(1, 0): 1, (2, 1): 1},
    (2, 1): {(2, 0): 1, (1, 1): 1}
}

start = (0, 0)
goal = (2, 1)
path = a_star_search(graph, start, goal)
print("Кратчайший путь:", path)

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

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

📊 Прогнозирование временных рядов с использованием рекуррентных нейронных сетей (RNN)

import numpy as np
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

def prepare_data(series, time_step=1):
    X, y = [], []
    for i in range(len(series) - time_step):
        X.append(series)
        y.append(series)
    return np.array(X), np.array(y)

# Генерация временного ряда
data = np.sin(np.linspace(0, 100, 500)) + np.random.normal(0, 0.1, 500)
scaler = MinMaxScaler(feature_range=(0, 1))
data = scaler.fit_transform(data.reshape(-1, 1)).flatten()

# Подготовка данных
time_step = 10
X, y = prepare_data(data, time_step)
X = X.reshape(X.shape[0], X.shape[1], 1)

# Создание модели RNN
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(time_step, 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mean_squared_error')

# Обучение модели
model.fit(X, y, epochs=100, batch_size=32, verbose=1)

# Пример использования
test_data = data[-time_step:]
test_data = test_data.reshape(1, -1, 1)
prediction = model.predict(test_data)
print("Прогноз:", scaler.inverse_transform(prediction).flatten()[0])

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

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

Тестирование мета-роев

Простой пример работы мета-роя.

1️⃣ Получен вопрос от пользователя.
2️⃣ RAG-агенты из rag-роя параллельно начали поиск информации в своих знаниях.
3️⃣ Один RAG-агент нашёл у себя инфу, другой — нет.
4️⃣ Запустился мета-рой с входными данными от rag-роя.
5️⃣ User-agent в мета-рое нашёл полезную инфу и вернул её пользователю.

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

🎯 Создание рекомендательной системы на основе коллаборативной фильтрации

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def collaborative_filtering(user_item_matrix, user_id, top_n=5):
    # Вычисление косинусного сходства между пользователями
    user_similarity = cosine_similarity(user_item_matrix)
    
    # Получение рекомендаций для конкретного пользователя
    user_ratings = user_item_matrix
    similar_users = user_similarity
    
    # Умножение матрицы предпочтений на сходство и нормализация
    weighted_sum = similar_users @ user_item_matrix
    sum_of_weights = np.abs(similar_users).sum(axis=0)
    recommendations = weighted_sum / sum_of_weights
    
    # Избегаем уже оцененных пользователем элементов
    recommendations = 0
    
    # Получение топ-N рекомендаций
    top_recommendations = np.argsort(recommendations)[-top_n:][::-1]
    return top_recommendations

# Пример использования
user_item_matrix = np.array([
    [4, 0, 0, 5, 1],
    [0, 3, 4, 0, 0],
    [2, 0, 0, 3, 0],
    [0, 0, 4, 0, 4],
    [5, 4, 0, 0, 0]
])

user_id = 0
top_recommendations = collaborative_filtering(user_item_matrix, user_id)
print("Рекомендации для пользователя:", top_recommendations)

📌 Этот код реализует простую рекомендательную систему, использующую коллаборативную фильтрацию на основе пользовательского сходства. Косинусное сходство вычисляется для нахождения похожих пользователей, а затем используется для предсказания рейтингов товаров, которые пользователь ещё не оценил. Такой подход широко применяется в e-commerce для улучшения пользовательского опыта и увеличения продаж.

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

Сегодня закончится распродажа Stepik, чтобы взять все и сразу 👉 берите максимальную программу обучения FullStack Developer and Data Scientist (Python+JS+Data+CookBook) 🔥🔥🔥

КУПИТЬ КУРС МОЖНО ЗА СЧЕТ РАБОТАДАТЕЛЯ 📌📌📌

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

🤖 Разработка простого чат-бота с использованием NLP и TF-IDF

import nltk
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

nltk.download('punkt')

class SimpleChatBot:
    def __init__(self, responses):
        self.responses = responses
        self.vectorizer = TfidfVectorizer()
        self.tfidf_matrix = self.vectorizer.fit_transform(self.responses)

    def get_response(self, user_input):
        # Векторизация пользовательского ввода
        user_tfidf = self.vectorizer.transform()
        
        # Вычисление косинусного сходства
        similarities = cosine_similarity(user_tfidf, self.tfidf_matrix)
        
        # Выбор наилучшего ответа
        best_match_idx = np.argmax(similarities, axis=1)
        return self.responses[best_match_idx[0]]

# Пример использования
responses = [
    "Привет! Как я могу помочь?",
    "Я могу ответить на ваши вопросы.",
    "Извините, я не понимаю ваш запрос.",
    "Спасибо за обращение!"
]

chat_bot = SimpleChatBot(responses)
user_input = "Как вы можете помочь?"
response = chat_bot.get_response(user_input)
print("Бот:", response)

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

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

🔄 Асинхронное скачивание веб-страниц с помощью asyncio

import asyncio
import aiohttp
from aiohttp import ClientError

async def fetch(session, url):
    try:
        async with session.get(url) as response:
            return await response.text()
    except ClientError as e:
        print(f"Ошибка при загрузке {url}: {e}")
        return None

async def download_pages(urls):
    async with aiohttp.ClientSession() as session:
        tasks = 
        return await asyncio.gather(*tasks)

# Пример использования
urls = [
    "https://example.com",
    "https://example.org",
    "https://example.net"
]

async def main():
    pages = await download_pages(urls)
    for i, page in enumerate(pages):
        if page:
            print(f"Содержимое страницы {urls} загружено.")
        else:
            print(f"Не удалось загрузить страницу {urls}.")

asyncio.run(main())

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

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

Внедрение за две недели

Лучший свой MVP и сразу внедрение я сделал в ~2002 году, у меня был компьютерный салон (ну где школота за деньги могла рубиться в контру и прочие радости).

Я нанял работников, и выручка упала (стали воровать).

Тогда я сел и за две недели, не выходя из салона, написал систему управления компьютерным залом под Windows. TCP/IP, клиент-сервер и т.д.

Каждый день (ну, может, кроме первых 2-3 дней) я выкатывал новую версию на все компы и на комп админа. И сразу в бою тестировал. Были баги, глюки, хитрая школота находила способы убить мой процесс и разлочить комп. Но спустя две недели всё заработало как надо.

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

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

Кстати, скоро мы соберём фреймворк, на котором можно будет выкатить мультиагентную систему с RAG за 2-3 дня 🔥

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

📸 Обработка изображений с помощью OpenCV

import cv2
import numpy as np

def apply_grayscale_and_edges(image_path: str):
    # Загрузка изображения
    image = cv2.imread(image_path)
    if image is None:
        raise FileNotFoundError(f"Не удалось загрузить изображение: {image_path}")
    
    # Преобразование в градации серого
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Обнаружение границ с помощью Canny
    edges = cv2.Canny(gray_image, 100, 200)
    
    # Отображение результатов
    cv2.imshow("Grayscale", gray_image)
    cv2.imshow("Edges", edges)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# Пример использования
image_path = "example.jpg"
try:
    apply_grayscale_and_edges(image_path)
except FileNotFoundError as e:
    print(e)

📌 Этот код демонстрирует работу с изображениями с помощью OpenCV: загрузка, преобразование в градации серого и обнаружение границ. Эти операции полезны для задач компьютерного зрения, таких как распознавание объектов или улучшение изображений для анализа.

🛠 Установите OpenCV с помощью: pip install opencv-python-headless

🔍 Применяйте этот код в своих проектах для обработки изображений.

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

🔍 Эффективность использования Generators vs. List Comprehensions в Python

def list_comprehension_example(n: int):
    return 

def generator_example(n: int):
    return (x * x for x in range(n))

# Пример использования
if __name__ == "__main__":
    n = 10**6

    # Использование спискового включения
    squares_list = list_comprehension_example(n)
    print(f"Сгенерирован список квадратов длиной {len(squares_list)}")

    # Использование генератора
    squares_generator = generator_example(n)
    print("Сгенерирован генератор квадратов")

    # Пример итерации по генератору
    sum_of_squares = sum(squares_generator)
    print(f"Сумма квадратов до {n}: {sum_of_squares}")

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

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

Генераторы полезны при работе с большими данными, когда важно снижать нагрузку на оперативную память.

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

🔄 Асинхронное программирование vs. многопоточность в Python

import asyncio
import concurrent.futures
import requests

async def fetch_url_async(url: str) -> str:
    loop = asyncio.get_event_loop()
    with concurrent.futures.ThreadPoolExecutor() as pool:
        response = await loop.run_in_executor(pool, requests.get, url)
        return response.text

def fetch_url_sync(url: str) -> str:
    response = requests.get(url)
    return response.text

async def main():
    url = "https://www.example.com"
    
    # Асинхронный вызов
    async_result = await fetch_url_async(url)
    print("Асинхронный результат получен")

    # Синхронный вызов
    with concurrent.futures.ThreadPoolExecutor() as executor:
        future = executor.submit(fetch_url_sync, url)
        sync_result = future.result()
        print("Синхронный результат получен")

if __name__ == "__main__":
    asyncio.run(main())

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

Асинхронная функция fetch_url_async использует asyncio и ThreadPoolExecutor для выполнения запросов без блокировки основного потока,
в то время как синхронная функция fetch_url_sync выполняет их в отдельном потоке.

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

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

💡 Генераторы vs. Списочные включения: Эффективная обработка данных

def process_large_file(file_path: str) -> int:
    """Считает количество строк, содержащих слово 'Python' в большом файле."""
    count = 0
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            for line in file:
                if 'Python' in line:
                    count += 1
    except FileNotFoundError:
        print(f"Файл {file_path} не найден.")
    except Exception as error:
        print(f"Произошла ошибка: {error}")
    return count

# Пример использования
file_path = 'large_text_file.txt'
python_count = process_large_file(file_path)
print(f"Количество строк с 'Python': {python_count}")

📌 Использование генераторов позволяет обрабатывать большие файлы без значительного потребления памяти. Этот код открывает файл и читает его по одной строке, проверяя наличие слова 'Python'.

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

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

🛠️ Автоматизация тестирования API с Pytest и Requests

import requests
import pytest

BASE_URL = "https://jsonplaceholder.typicode.com"

def test_get_post():
    response = requests.get(f"{BASE_URL}/posts/1")
    assert response.status_code == 200
    assert response.json()["id"] == 1

def test_create_post():
    new_post = {"title": "foo", "body": "bar", "userId": 1}
    response = requests.post(f"{BASE_URL}/posts", json=new_post)
    assert response.status_code == 201
    assert response.json()["title"] == new_post["title"]

def test_update_post():
    updated_data = {"title": "foobar"}
    response = requests.put(f"{BASE_URL}/posts/1", json=updated_data)
    assert response.status_code == 200
    assert response.json()["title"] == updated_data["title"]

def test_delete_post():
    response = requests.delete(f"{BASE_URL}/posts/1")
    assert response.status_code == 200

if __name__ == "__main__":
    pytest.main()

📌 Этот код демонстрирует, как использовать Pytest и Requests для автоматизации тестирования API. Он включает тесты для операций GET, POST, PUT и DELETE, что позволяет убедиться в корректной работе вашего API. Эти тесты могут быть интегрированы в CI/CD процессы, чтобы автоматически проверять API при каждом обновлении кода.

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

🔍 Автоматизированная система мониторинга веб-сайтов с BeautifulSoup и Selenium

from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
import requests
import time

def get_page_content(url: str) -> str:
    try:
        response = requests.get(url)
        response.raise_for_status()
        return response.text
    except requests.RequestException as e:
        print(f"Ошибка при получении содержимого страницы: {e}")
        return ""

def parse_content(html: str) -> str:
    soup = BeautifulSoup(html, 'html.parser')
    title = soup.find('title').text if soup.find('title') else 'Заголовок не найден'
    return title

def monitor_website(url: str, check_interval: int):
    content = get_page_content(url)
    current_title = parse_content(content)
    print(f"Начальный заголовок: {current_title}")

    options = Options()
    options.headless = True
    service = Service('/path/to/chromedriver')
    driver = webdriver.Chrome(service=service, options=options)
    driver.get(url)

    try:
        while True:
            driver.refresh()
            new_content = driver.page_source
            new_title = parse_content(new_content)
            if new_title != current_title:
                print(f"Содержание сайта изменилось! Новый заголовок: {new_title}")
                current_title = new_title
            time.sleep(check_interval)
    except Exception as e:
        print(f"Ошибка во время мониторинга: {e}")
    finally:
        driver.quit()

# Пример использования
monitor_website("https://example.com", check_interval=60)

📌 Этот код демонстрирует, как автоматически отслеживать изменения на веб-сайте, используя BeautifulSoup для парсинга HTML и Selenium для управления браузером. Система периодически проверяет заголовок страницы и уведомляет о любых изменениях. Это может быть полезно для мониторинга изменений на важных веб-ресурсах и своевременного реагирования на них.

🛠 pip install beautifulsoup4 selenium requests

💡 Не забудьте скачать и указать путь к chromedriver для корректной работы Selenium.

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

📄 Автоматизация обработки документов с использованием PyPDF2

import PyPDF2

def merge_pdfs(pdf_list, output_path):
    pdf_writer = PyPDF2.PdfWriter()
    
    for pdf_file in pdf_list:
        try:
            with open(pdf_file, 'rb') as file:
                pdf_reader = PyPDF2.PdfReader(file)
                for page in range(len(pdf_reader.pages)):
                    pdf_writer.add_page(pdf_reader.pages)
        except Exception as e:
            print(f"Ошибка при чтении {pdf_file}: {e}")
    
    try:
        with open(output_path, 'wb') as output_pdf:
            pdf_writer.write(output_pdf)
        print(f"Объединенный PDF сохранен как {output_path}")
    except Exception as e:
        print(f"Ошибка при записи объединенного PDF: {e}")

# Пример использования
pdf_files = ["document1.pdf", "document2.pdf"]
merge_pdfs(pdf_files, "merged_document.pdf")

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

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

🕸️ Автоматизация сбора данных с веб-форм с помощью Selenium

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
import time

def setup_driver():
    chrome_options = Options()
    chrome_options.add_argument("--headless")  # Запуск браузера в режиме без интерфейса
    service = Service(executable_path='path/to/chromedriver')
    driver = webdriver.Chrome(service=service, options=chrome_options)
    return driver

def fill_form_and_submit(url, form_data):
    driver = setup_driver()
    try:
        driver.get(url)
        for field_id, value in form_data.items():
            element = driver.find_element(By.ID, field_id)
            element.clear()  # Очистка существующего текста в поле
            element.send_keys(value)  # Ввод нового текста
        
        submit_button = driver.find_element(By.ID, "submit")
        submit_button.click()
        
        time.sleep(3)  # Ожидание загрузки страницы
        return driver.page_source
    except Exception as e:
        print(f"Ошибка при отправке формы: {e}")
    finally:
        driver.quit()

# Пример использования
url = "http://example.com/form"
form_data = {
    "name": "John Doe",
    "email": "john.doe@example.com",
    "message": "Hello, this is a test message!"
}
response = fill_form_and_submit(url, form_data)
print(response[:500])  # Вывод первых 500 символов HTML страницы

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

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

👉 Ключевой бесплатный курс для разминки мозга 🤯 и понимания как работает компьютер 💻

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