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

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 (быстрый курс) 🔥

🏃🏃‍♀️🏃‍♂️

⚡ Асинхронные сетевые операции с asyncio

import asyncio
import aiohttp

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

async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return responses

# Пример использования
urls = [
    "https://www.example.com",
    "https://www.python.org",
    "https://www.asyncio.org"
]
results = asyncio.run(main(urls))
for url, content in zip(urls, results):
    print(f"Содержимое {url[:30]}: {content[:100]}...")

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

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

🧪 Автоматизация тестирования с помощью PyTest

import pytest

# Пример функции сложения
def add(a: int, b: int) -> int:
    return a + b

# Параметризация тестов для проверки функции сложения
@pytest.mark.parametrize("a, b, expected", [
    (1, 1, 2),
    (2, 3, 5),
    (10, -10, 0),
    (-1, -1, -2)
])
def test_add_parametrized(a, b, expected):
    assert add(a, b) == expected

# Запуск тестов
# В командной строке выполните: pytest имя_файла.py

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

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

🎮 Реализация мультиплеера с WebSockets

import asyncio
import websockets
import json

connected_clients = set()

async def handle_connection(websocket, path):
    # Добавляем нового клиента в набор подключенных
    connected_clients.add(websocket)
    try:
        async for message in websocket:
            data = json.loads(message)
            action = data.get("action")

            if action == "broadcast":
                await broadcast(data)
            elif action == "sync":
                await sync_game_state(websocket, data)
            
    except websockets.exceptions.ConnectionClosed:
        print(f"Клиент отключился: {websocket}")
    finally:
        connected_clients.remove(websocket)

async def broadcast(data):
    message = json.dumps(data)
    for client in connected_clients:
        await client.send(message)

async def sync_game_state(websocket, data):
    # Здесь можно обработать синхронизацию состояния игры
    await websocket.send(json.dumps({"status": "synced"}))

async def main():
    async with websockets.serve(handle_connection, "localhost", 8765):
        await asyncio.Future()  # Ожидание завершения

# Пример использования
asyncio.run(main())

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

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

Ускорение работы с данными с помощью numpy

import numpy as np
import timeit

# Создание больших массивов чисел
array_size = 10**6
python_list = list(range(array_size))
numpy_array = np.arange(array_size)

# Функция для суммирования элементов с использованием чистого Python
def sum_python(lst):
    return sum(lst)

# Функция для суммирования элементов с использованием numpy
def sum_numpy(arr):
    return np.sum(arr)

# Измерение времени выполнения для обеих функций
python_duration = timeit.timeit(lambda: sum_python(python_list), number=1)
numpy_duration = timeit.timeit(lambda: sum_numpy(numpy_array), number=1)

print(f"Python: {python_duration:.5f} seconds")
print(f"Numpy: {numpy_duration:.5f} seconds")

📌 Этот код демонстрирует, насколько быстрее numpy может обрабатывать большие массивы по сравнению с чистым Python. Используя numpy, можно значительно ускорить операции, такие как суммирование, благодаря оптимизированным C-расширениям. Это особенно полезно в научных и финансовых приложениях, где важна работа с большими объемами данных и высокая производительность.

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

🔮 Устойчивая обработка ошибок с монадами Maybe

from typing import Generic, TypeVar, Union, Callable

T = TypeVar('T')

class Maybe(Generic[T]):
    def __init__(self, value: Union[T, None]):
        self.value = value

    def is_nothing(self) -> bool:
        return self.value is None

    def map(self, func: Callable[[T], T]) -> 'Maybe[T]':
        if self.is_nothing():
            return self
        try:
            return Maybe(func(self.value))
        except Exception:
            return Maybe(None)

    def get_or_else(self, default: T) -> T:
        return self.value if not self.is_nothing() else default

# Пример использования
def safe_divide(x: float, y: float) -> Maybe[float]:
    if y == 0:
        return Maybe(None)
    return Maybe(x / y)

result = safe_divide(10, 2).map(lambda x: x * 100).get_or_else(0)
print(result)  # Вывод: 500.0

result = safe_divide(10, 0).map(lambda x: x * 100).get_or_else(0)
print(result)  # Вывод: 0

📌 Монада Maybe помогает избежать ошибок, связанных с использованием None или делением на ноль. Вместо выбрасывания исключений, функция возвращает объект Maybe, который можно безопасно обрабатывать с помощью методов map и get_or_else. Это делает код более предсказуемым и устойчивым к ошибкам, особенно полезно в API-интерфейсах и при работе с неполными данными.

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

💡 Управление светодиодами с MicroPython

from machine import Pin
from time import sleep

def blink_led(pin_number: int, delay: float = 0.5):
    try:
        led = Pin(pin_number, Pin.OUT)
        while True:
            led.on()
            sleep(delay)
            led.off()
            sleep(delay)
    except KeyboardInterrupt:
        print("Программа остановлена пользователем")
    except Exception as e:
        print(f"Произошла ошибка: {e}")

# Пример использования
if __name__ == "__main__":
    blink_led(pin_number=2)

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

MicroPython предоставляет более высокий уровень абстракции над аппаратными компонентами по сравнению с C/C++, что упрощает процесс разработки и прототипирования. Данный пример может быть полезен для создания простых устройств, таких как индикаторы состояния или световые эффекты в проектах с микроконтроллерами.

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