🚀 Внедрение CI/CD для Python-проектов с GitHub Actions

name: CI/CD Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.8

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run tests
        run: pytest

  deploy:
    runs-on: ubuntu-latest
    needs: test
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Deploy to Production
        run: echo "Deploying application..."

📌 Этот YAML-файл описывает базовый CI/CD конвейер для Python-проекта с использованием GitHub Actions. Он включает две задачи: тестирование и развертывание. При каждом коммите в ветку main запускаются тесты с помощью pytest, и в случае их успешного прохождения выполняется развертывание. Это помогает автоматизировать процессы разработки и уменьшает вероятность ошибок при развертывании.

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

⚡️⚡️⚡️ Доступ к продаже следующих курсов закрывается сегодня ⚡️⚡️⚡️

👉 Python: самый быстрый курс 🔥🔥🔥
👉 Python Data Science: самый быстрый курс 🔥
👉 JavaScript: самый быстрый курс 🔥🔥

🗺️ Обработка и визуализация геоданных с GeoPandas

import geopandas as gpd
from shapely.geometry import Point

def load_geodata(file_path: str) -> gpd.GeoDataFrame:
    try:
        return gpd.read_file(file_path)
    except FileNotFoundError:
        print("Файл не найден.")
    except Exception as e:
        print(f"Ошибка при чтении файла: {e}")
    return gpd.GeoDataFrame()

def create_point_geodataframe(latitudes: list, longitudes: list) -> gpd.GeoDataFrame:
    if len(latitudes) != len(longitudes):
        print("Списки широт и долгот должны быть одинаковой длины.")
        return gpd.GeoDataFrame()
    geometry = [Point(xy) for xy in zip(longitudes, latitudes)]
    return gpd.GeoDataFrame(geometry=geometry, crs="EPSG:4326")

def filter_data_by_region(gdf: gpd.GeoDataFrame, region_name: str) -> gpd.GeoDataFrame:
    try:
        return gdf[gdf['region'] == region_name]
    except KeyError:
        print(f"Колонка 'region' отсутствует в данных.")
    return gpd.GeoDataFrame()

# Пример использования
if __name__ == "__main__":
    # Загрузка геоданных
    geodata = load_geodata("example.geojson")
    
    # Создание GeoDataFrame из координат
    latitudes = [37.7749, 34.0522]
    longitudes = [-122.4194, -118.2437]
    points = create_point_geodataframe(latitudes, longitudes)
    
    # Фильтрация по региону
    filtered_data = filter_data_by_region(geodata, "California")
    print(filtered_data)

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

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

🚀 Оптимизация кода с мемоизацией

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n: int) -> int:
    """Рассчитывает n-е число Фибоначчи с мемоизацией."""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# Пример использования
print(fibonacci(10))  # Вывод: 55

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

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

🚀 Функциональные и реактивные подходы в веб-разработке с Flask и React

from flask import Flask, jsonify, request
from functools import partial
from concurrent.futures import ThreadPoolExecutor

app = Flask(__name__)

# Функция для обработки данных
def process_data(data: dict, multiplier: int) -> dict:
    return {k: v * multiplier for k, v in data.items()}

# Обработчик запросов, использующий функциональные принципы
@app.route('/process', methods=['POST'])
def process_request():
    try:
        data = request.json
        if not data:
            raise ValueError("Отсутствуют JSON-данные")

        multiplier = data.get('multiplier', 1)
        if not isinstance(multiplier, int):
            raise ValueError("Multiplier должен быть целым числом")

        values = data.get('values')
        if not isinstance(values, dict):
            raise ValueError("Values должен быть словарем")

        process = partial(process_data, values, multiplier)
        
        with ThreadPoolExecutor() as executor:
            result = executor.submit(process).result()

        return jsonify(result), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

# Пример использования: отправка POST-запроса с JSON-данными
# curl -X POST http://localhost:5000/process -H "Content-Type: application/json" -d '{"values": {"a": 1, "b": 2}, "multiplier": 3}'

📌 Этот код демонстрирует использование функциональных принципов в Flask для обработки данных. Применяя functools.partial и ThreadPoolExecutor, мы улучшаем производительность и отзывчивость серверной части приложения. Эти подходы позволяют легко масштабировать и тестировать серверные компоненты, что особенно полезно при высокой нагрузке.

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

🚀 Оптимизация моделей машинного обучения с Optuna

import optuna
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score

# Загрузка данных и разделение на обучающую и тестовую выборки
data = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

def objective(trial):
    n_estimators = trial.suggest_int('n_estimators', 10, 100)
    max_depth = trial.suggest_int('max_depth', 2, 32, log=True)
    min_samples_split = trial.suggest_int('min_samples_split', 2, 10)

    clf = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        min_samples_split=min_samples_split,
        random_state=42
    )
    
    # Кросс-валидация с параллельными вычислениями
    return cross_val_score(clf, X_train, y_train, n_jobs=-1, cv=3).mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)

print(f'Лучшие параметры: {study.best_params}')
print(f'Лучшая точность кросс-валидации: {study.best_value:.2f}')

# Пример использования с найденными гиперпараметрами
best_clf = RandomForestClassifier(**study.best_params)
best_clf.fit(X_train, y_train)
accuracy = best_clf.score(X_test, y_test)
print(f'Точность на тестовом наборе: {accuracy:.2f}')

📌 Этот код показывает, как использовать Optuna для автоматизации настройки гиперпараметров модели RandomForest. Optuna помогает находить оптимальные параметры, чтобы улучшить точность модели. Использование n_jobs=-1 позволяет выполнять кросс-валидацию параллельно, что ускоряет процесс.

🛠 pip install optuna scikit-learn

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

🌿 Симуляция клеточных автоматов для моделирования экосистем

import pygame
import random

# Константы
WINDOW_SIZE = 600
GRID_SIZE = 30
CELL_SIZE = WINDOW_SIZE // GRID_SIZE

# Инициализация Pygame
pygame.init()
window = pygame.display.set_mode((WINDOW_SIZE, WINDOW_SIZE))
clock = pygame.time.Clock()

def create_grid():
    return [[random.choice([0, 1]) for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]

def update_grid(grid):
    new_grid = [[0] * GRID_SIZE for _ in range(GRID_SIZE)]
    for y in range(GRID_SIZE):
        for x in range(GRID_SIZE):
            alive_neighbors = sum([grid[y+dy][x+dx] for dx in [-1, 0, 1] if 0 <= x+dx < GRID_SIZE
                                   for dy in [-1, 0, 1] if 0 <= y+dy < GRID_SIZE and (dx != 0 or dy != 0)])
            if grid[y][x] == 1 and alive_neighbors in (2, 3):
                new_grid[y][x] = 1
            elif grid[y][x] == 0 and alive_neighbors == 3:
                new_grid[y][x] = 1
    return new_grid

def draw_grid(grid):
    for y in range(GRID_SIZE):
        for x in range(GRID_SIZE):
            color = (0, 255, 0) if grid[y][x] == 1 else (0, 0, 0)
            pygame.draw.rect(window, color, (x*CELL_SIZE, y*CELL_SIZE, CELL_SIZE, CELL_SIZE))

# Основной цикл
grid = create_grid()
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    grid = update_grid(grid)
    window.fill((0, 0, 0))
    draw_grid(grid)
    pygame.display.flip()
    clock.tick(10)

pygame.quit()

📌 Этот код создает симуляцию клеточного автомата с использованием Pygame. Клеточные автоматы моделируют экосистемы через сетку клеток, где каждая клетка может быть "живой" или "мёртвой". Симуляция обновляется по правилам, что позволяет исследовать, как развиваются структуры во времени.

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

🔥 Создание системы частиц в Pygame

import pygame
import random
import sys

# Инициализация Pygame
pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

class Particle:
    def __init__(self, pos, vel, color, lifespan):
        self.pos = list(pos)
        self.vel = list(vel)
        self.color = color
        self.lifespan = lifespan

    def update(self):
        self.pos[0] += self.vel[0]
        self.pos[1] += self.vel[1]
        self.lifespan -= 1

    def draw(self, screen):
        if self.lifespan > 0:
            pygame.draw.circle(screen, self.color, (int(self.pos[0]), int(self.pos[1])), 3)

def create_particles(count, pos):
    particles = []
    for _ in range(count):
        particles.append(Particle(
            pos=pos,
            vel=(random.uniform(-1, 1), random.uniform(-1, 1)),
            color=(255, 255, 255),
            lifespan=random.randint(20, 100)
        ))
    return particles

particles = create_particles(100, (400, 300))

# Главный цикл
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

    screen.fill((0, 0, 0))

    for particle in particles[:]:
        particle.update()
        particle.draw(screen)
        if particle.lifespan <= 0:
            particles.remove(particle)

    pygame.display.flip()
    clock.tick(60)

📌 Этот код создает простую систему частиц в Pygame, где частицы возникают в центре экрана и со временем затухают. Система обновляет позиции частиц, изменяет их состояние и удаляет их, когда они "умирают". Такой код может быть использован для создания эффектов, таких как дым или огонь, в 2D-играх.

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

Наша новая статья ИИ-агенты без оркестрации и роутинга на habr.

Больше по теме в канале 👉🏻 @aigentto 🤖

Мясной слой для ИИ-агентов

Пока Elon Musk ещё не продает массово своих роботов Optimus 3, появилась замена. Теперь любой ИИ-агент может арендовать человека для выполнения задач в реальном мире 😄

Как я вижу, спрос со стороны людей пока превышает количество задач со стороны ИИ.

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

Бывают такие задачи, например, позвонить куда-то и узнать что-то, или даже ответить на вопрос по данным, когда LLM не смог справиться.

API тут https://rentahuman.ai/mcp. Доступные люди тут https://rentahuman.ai/browse.

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

🔧 Функциональное программирование с functools и itertools

from itertools import chain
from collections import defaultdict

def process_data(data):
    # Объединяем элементы из вложенных списков
    combined = chain.from_iterable(data)
    
    # Группируем и суммируем значения по ключу
    result = defaultdict(int)
    for key, value in combined:
        result[key] += value
    
    return dict(result)

# Пример использования
data = [[('apple', 10), ('banana', 5)], [('apple', 3), ('banana', 2)], [('banana', 1)]]
result = process_data(data)
print(result)  # Вывод: {'apple': 13, 'banana': 8}

📌 Этот код демонстрирует использование itertools.chain для объединения списков и collections.defaultdict для упрощения группировки и суммирования данных. Такой подход полезен для эффективной обработки и агрегирования больших наборов данных.

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

💰 Реализация внутриигровых покупок с Flask

from flask import Flask, jsonify, request, abort
from dataclasses import dataclass, asdict

app = Flask(__name__)

# Модель покупки
@dataclass
class Purchase:
    item_id: int
    user_id: int
    amount: float

# Пример данных
purchases = []

@app.route('/purchase', methods=['POST'])
def create_purchase():
    if not request.json or 'item_id' not in request.json or 'user_id' not in request.json:
        abort(400, description="Неправильный запрос: отсутствует item_id или user_id.")
    if request.json.get('amount', 0.0) <= 0:
        abort(400, description="Неправильный запрос: сумма должна быть положительной.")
    purchase = Purchase(
        item_id=request.json['item_id'],
        user_id=request.json['user_id'],
        amount=request.json['amount']
    )
    purchases.append(purchase)
    return jsonify({'purchase': asdict(purchase)}), 201

# Flask сервер
if __name__ == '__main__':
    app.run(debug=True)

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

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

🎮 Игра с нестандартной гравитацией на Pygame

import pygame
import sys

# Инициализация Pygame
pygame.init()

# Константы
WIDTH, HEIGHT = 800, 600
INVERTED_GRAVITY = -0.1  # Обратная гравитация

# Настройка окна
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Игра с нестандартной гравитацией")

# Игровой объект (шар)
ball = pygame.Rect(WIDTH // 2, HEIGHT // 2, 30, 30)
ball_speed_y = 0

# Основной игровой цикл
clock = pygame.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
    
    # Обновление скорости шара
    ball_speed_y += INVERTED_GRAVITY
    ball.y += ball_speed_y

    # Проверка на столкновение с границами окна
    if ball.top < 0 or ball.bottom > HEIGHT:
        ball_speed_y = -ball_speed_y
        # Коррекция позиции шара после столкновения
        ball.y = max(0, min(ball.y, HEIGHT - ball.height))

    # Отрисовка
    screen.fill((0, 0, 0))  # Черный фон
    pygame.draw.ellipse(screen, (255, 0, 0), ball)  # Красный шар
    pygame.display.flip()
    
    # Ограничение FPS
    clock.tick(60)

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

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

🧠 Классификация с Scikit-learn: Введение в машинное обучение

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

def classify_iris():
    # Загрузка набора данных Iris
    iris = load_iris()
    X, y = iris.data, iris.target
    
    # Разделение данных на обучающую и тестовую выборки
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # Создание и обучение модели
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    
    # Предсказание и оценка точности модели
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    
    return accuracy

# Пример использования
model_accuracy = classify_iris()
print(f"Точность модели: {model_accuracy:.2f}")

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

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

🎮 Начало разработки игр с Pygame

import pygame
import sys

# Инициализация Pygame
pygame.init()

# Настройка окна
screen_size = (800, 600)
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption("Простая 2D-игра")

# Основной игровой цикл
def game_loop():
    clock = pygame.time.Clock()
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
        
        # Заливка фона
        screen.fill((0, 0, 0))  # Черный цвет
        
        # Обновление дисплея
        pygame.display.flip()
        
        # Ограничение кадров в секунду
        clock.tick(60)

# Запуск игры
if __name__ == "__main__":
    game_loop()

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

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

Визуализация данных в реальном времени с Bokeh и WebSockets

from bokeh.plotting import figure, curdoc
from bokeh.models import ColumnDataSource
from bokeh.layouts import layout
from tornado import gen
from threading import Thread
import random
import time

# Источник данных для графика
source = ColumnDataSource(data={'x': [], 'y': []})

# Создаем график
plot = figure(title="Данные в реальном времени", x_axis_label='Время', y_axis_label='Значение')
plot.line('x', 'y', source=source)

# Функция для обновления данных
@gen.coroutine
def update():
    new_data = {'x': [time.time()], 'y': [random.randint(0, 100)]}
    source.stream(new_data, rollover=100)

def update_data():
    while True:
        time.sleep(1)
        curdoc().add_next_tick_callback(update)

# Запускаем поток для обновления данных
thread = Thread(target=update_data)
thread.start()

# Создаем и запускаем сервер Bokeh
curdoc().add_root(layout([plot]))

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

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

🔗 Функциональные шаблоны проектирования в Python: Каррирование и Композиция

from functools import partial

def add(a, b, c):
    return a + b + c

# Каррирование
add_to_10 = partial(add, 10)
result_curried = add_to_10(5, 15)

# Композиция
def compose(f, g):
    def composed(x):
        return f(g(x))
    return composed

def double(x):
    return x * 2

def increment(x):
    return x + 1

# Пример композиции функций
composed_function = compose(double, increment)
result_composed = composed_function(3)

print(result_curried)  # Результат: 30
print(result_composed)  # Результат: 8

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

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

⚡️ Оптимизация с многопоточностью и асинхронностью

import asyncio
import concurrent.futures
import time

def cpu_bound_task(n: int) -> int:
    print(f"Выполняю тяжёлую задачу для {n}...")
    time.sleep(2)  # Имитация длительного вычисления
    return n * n

async def async_main(nums: list):
    if not nums:
        print("Список чисел пуст.")
        return
    loop = asyncio.get_running_loop()
    with concurrent.futures.ProcessPoolExecutor() as pool:
        results = await asyncio.gather(
            *[loop.run_in_executor(pool, cpu_bound_task, num) for num in nums]
        )
    return results

# Пример использования
if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 5]
    start = time.time()
    results = asyncio.run(async_main(numbers))
    end = time.time()
    print(f"Результаты: {results}")
    print(f"Время выполнения: {end - start:.2f} секунд")

📌 Этот код демонстрирует использование многопоточности и асинхронности для оптимизации выполнения CPU-интенсивных задач в Python. Мы используем concurrent.futures.ProcessPoolExecutor в сочетании с asyncio для параллельной обработки задач, что позволяет значительно ускорить выполнение по сравнению с последовательным вариантом. Это полезно при работе с задачами, требующими длительных вычислений, такими как обработка данных или сложные вычисления. Убедитесь, что список чисел не пустой, чтобы избежать ненужных вычислений.

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

🚀 Последний шанс купить следующие программы курсов:

👉 FullStack Developer and Data Scientist (Python+JS+Data+CookBook)🔥🔥🔥

👉 Junior FullStack Developer: Python+JavaScript (быстрый курс) 🔥

⚡️⚡️⚡️ Только до 28 февраля ⚡️⚡️⚡️

🧬 Симуляция эволюции популяции с DEAP

import random
from deap import base, creator, tools, algorithms

# Создание классов для максимизации функции
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

def eval_function(individual):
    return sum(individual),

toolbox = base.Toolbox()
toolbox.register("attr_float", random.random)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=5)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", eval_function)

def main():
    random.seed(42)
    pop = toolbox.population(n=10)
    algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=20, verbose=True)

if __name__ == "__main__":
    main()

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

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

⚡️⚡️⚡️ Доступ к продаже следующих программ курсов закрывается сегодня ⚡️⚡️⚡️

👉 FullStack Developer and Data Scientist (Python+JS+Data+CookBook)🔥🔥🔥

👉 Junior FullStack Developer: Python+JavaScript (быстрый курс) 🔥

🏃🏃‍♀️🏃‍♂️