💰 Реализация внутриигровых покупок с 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 🤖

Создаем AI для игровых персонажей на Python 🎮

import random

class NPC:
    def __init__(self, name: str):
        self.name = name
        self.position = (0, 0)
    
    def patrol(self):
        # Перемещение в случайном направлении
        self.position = (self.position[0] + random.choice([-1, 1]),
                         self.position[1] + random.choice([-1, 1]))
        print(f"{self.name} патрулирует: {self.position}")
    
    def chase(self, target_position):
        # Перемещение в сторону цели
        direction_x = 0 if target_position[0] == self.position[0] else (1 if target_position[0] > self.position[0] else -1)
        direction_y = 0 if target_position[1] == self.position[1] else (1 if target_position[1] > self.position[1] else -1)
        self.position = (self.position[0] + direction_x,
                         self.position[1] + direction_y)
        print(f"{self.name} преследует игрока: {self.position}")

    def evade(self, threat_position):
        # Уклонение от угрозы
        direction_x = 0 if threat_position[0] == self.position[0] else (-1 if threat_position[0] > self.position[0] else 1)
        direction_y = 0 if threat_position[1] == self.position[1] else (-1 if threat_position[1] > self.position[1] else 1)
        self.position = (self.position[0] + direction_x,
                         self.position[1] + direction_y)
        print(f"{self.name} уклоняется от угрозы: {self.position}")

# Пример использования
npc = NPC("Гоблин")
npc.patrol()
npc.chase((5, 5))
npc.evade((3, 3))

📌 В этом коде реализован простой AI для NPC в играх. Он может патрулировать, преследовать игрока и уклоняться от угроз. Такой подход позволяет сделать игровой процесс более интерактивным и интересным.

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

💡 Lazy Evaluation и генераторы для обработки больших файлов

import logging

def read_large_file(file_path):
    try:
        with open(file_path, 'r') as file:
            yield from (line.strip() for line in file)
    except FileNotFoundError:
        logging.error(f"Файл {file_path} не найден.")
    except Exception as e:
        logging.error(f"Произошла ошибка: {e}")

def process_log_file(file_path):
    total_lines = 0
    error_count = 0

    for line in read_large_file(file_path):
        total_lines += 1
        if "ERROR" in line:
            error_count += 1

    return total_lines, error_count

# Пример использования
file_path = "server.log"
total_lines, error_count = process_log_file(file_path)
print(f"Всего строк: {total_lines}, ошибок: {error_count}")

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

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

🔄 Функциональные потоки данных с использованием itertools

from itertools import islice, chain

def process_large_data(data):
    # Пример использования itertools.chain для объединения нескольких списков
    combined_data = chain(data, ['дополнительно', 'данные'])
    
    # Пример использования itertools.islice для ленивой выборки данных
    sliced_data = islice(combined_data, 5)  # Возьмем только первые 5 элементов
    
    return list(sliced_data)

# Пример использования
data = ['элемент1', 'элемент2', 'элемент3']
print(process_large_data(data))

📌 Библиотека itertools предоставляет мощные инструменты для работы с итераторами, что помогает обрабатывать большие объемы данных эффективно. В этом примере chain объединяет списки, а islice позволяет отбирать элементы без использования циклов, что экономит память и улучшает производительность.

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

🎮 Разработка многопользовательской игры на Python с WebSockets

import asyncio
import websockets

connected_clients = set()

async def handle_connection(websocket, path):
    # Добавляем нового клиента в список подключений
    connected_clients.add(websocket)
    try:
        async for message in websocket:
            # Рассылаем сообщение всем подключенным клиентам
            await asyncio.gather(*[client.send(message) for client in connected_clients])
    except websockets.exceptions.ConnectionClosed:
        print(f"Клиент отключился: {websocket}")
    finally:
        # Удаляем клиента из списка подключений при отключении
        connected_clients.remove(websocket)

async def start_server():
    # Запуск WebSocket сервера на указанном порту
    server = await websockets.serve(handle_connection, "localhost", 8765)
    print("Сервер запущен на ws://localhost:8765")
    await server.wait_closed()

# Запуск сервера
asyncio.run(start_server())

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

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

🚀 Оптимизация производительности с помощью Cython

# example_cython.pyx
def cython_function(int n):
    cdef int i, total = 0
    for i in range(n):
        total += i
    return total

# Python-функция для сравнения
def python_function(n: int) -> int:
    total = 0
    for i in range(n):
        total += i
    return total

# Пример использования
if __name__ == "__main__":
    from time import time
    import pyximport
    pyximport.install()

    # Импортируем скомпилированный модуль
    import example_cython

    n = 10000000

    start = time()
    result_python = python_function(n)
    end = time()
    print(f"Python: {end - start:.2f} seconds, Result: {result_python}")

    start = time()
    result_cython = example_cython.cython_function(n)
    end = time()
    print(f"Cython: {end - start:.2f} seconds, Result: {result_cython}")

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

🛠 pip install Cython

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