Создание простой 3D-игры в Python можно выполнить с использованием библиотеки Ursina, которая позволяет работать с 3D-графикой, физикой и вводом данных.

### Установка Ursina
Если у вас не установлена библиотека Ursina, выполните:

pip install ursina

### Пример 3D-игры: Куб игрока и падающие препятствия
Вот код:

from ursina import *

# Создание приложения
app = Ursina()

# Игрок (управляемый куб)
player = Entity(model='cube', color=color.orange, scale=(1, 1, 1), position=(0, 0, 0))

# Препятствия
obstacles = []
for i in range(5):
    obstacle = Entity(model='cube', color=color.red, scale=(1, 1, 1),
                      position=(i * 2 - 4, 5, 0))
    obstacles.append(obstacle)

# Переменные игры
speed = 5
obstacle_speed = 2
score = 0
is_game_over = False

# Счётчик
score_text = Text(text=f'Score: {score}', position=(-0.7, 0.4), scale=2)

# Функция обновления
def update():
    global score, is_game_over

    if is_game_over:
        return

    # Управление игроком
    if held_keys['a']:
        player.x -= speed * time.dt
    if held_keys['d']:
        player.x += speed * time.dt

    # Движение препятствий
    for obstacle in obstacles:
        obstacle.y -= obstacle_speed * time.dt

        # Если препятствие достигло нижней части экрана
        if obstacle.y < -5:
            obstacle.y = 5
            obstacle.x = random.uniform(-4, 4)
            score += 1
            score_text.text = f'Score: {score}'

        # Проверка на столкновение с игроком
        if player.intersects(obstacle).hit:
            game_over()

def game_over():
    global is_game_over
    is_game_over = True
    Text(text="Game Over", origin=(0, 0), scale=2, color=color.red, position=(0, 0))
    score_text.text = f'Final Score: {score}'

# Функция для перезапуска игры
def restart():
    global is_game_over, score
    is_game_over = False
    score = 0
    score_text.text = f'Score: {score}'
    for obstacle in obstacles:
        obstacle.y = random.uniform(5, 10)
        obstacle.x = random.uniform(-4, 4)
    player.position = (0, 0, 0)

# Кнопка перезапуска
restart_button = Button(text="Restart", position=(0, -0.4), scale=(0.2, 0.1), visible=False)

def input(key):
    if key == 'space' and is_game_over:
        restart()

restart_button.on_click = restart

# Запуск приложения
app.run()

---

### Что делает этот код:
1. Игрок:
- Управляется клавишами A (влево) и D (вправо).
- Это оранжевый куб, который перемещается по горизонтали.

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

3. Счёт:
- Увеличивается на 1 каждый раз, когда препятствие пересекает нижнюю границу экрана.

4. Конец игры:
- При столкновении появляется текст "Game Over".
- Игру можно перезапустить нажатием клавиши Space.

---

### Как улучшить:
1. Добавить уровни сложности:
- Увеличивать скорость препятствий по мере увеличения счёта.
2. Добавить 3D-модель игрока:
- Заменить куб на, например, модель самолёта:

     player.model = 'sphere'
     

3. Добавить фон:
- Добавить текстуры или окружение с помощью Sky():

     sky = Entity(model='sphere', texture='sky_sunset', scale=100, double_sided=True)
     

4. Музыка и звуки:
- Добавить звуки при столкновении или наборе очков:

     Audio('explosion.wav', loop=False)
     

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

Код игры выше 👆👆👆

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

Для генерации музыки на Python можно использовать библиотеки, такие как MIDIUtil для создания MIDI-файлов или более сложные инструменты, например, Magenta от Google для генеративной музыки. Вот простой пример создания мелодии с помощью MIDIUtil:

### Пример: Создание простой мелодии в формате MIDI

from midiutil import MIDIFile

# Создаем объект MIDI-файла
midi = MIDIFile(1)  # Один трек
track = 0           # Номер трека
time = 0            # Начало мелодии с 0-й секунды
channel = 0         # Канал 0
volume = 100        # Громкость (0-127)

# Настройки для трека
midi.addTrackName(track, time, "Simple Melody")
midi.addTempo(track, time, 120)  # Устанавливаем темп (120 BPM)

# Ноты для мелодии (нотный ряд: (нота, время начала, продолжительность))
notes = [
    (60, 0, 1),  # До (C4), начало в 0 сек., длительность 1 сек.
    (62, 1, 1),  # Ре (D4), начало в 1 сек., длительность 1 сек.
    (64, 2, 1),  # Ми (E4)
    (65, 3, 1),  # Фа (F4)
    (67, 4, 1),  # Соль (G4)
    (69, 5, 1),  # Ля (A4)
    (71, 6, 1),  # Си (B4)
    (72, 7, 1),  # До (C5)
]

# Добавляем ноты в трек
for note, start_time, duration in notes:
    midi.addNote(track, channel, note, start_time, duration, volume)

# Сохраняем MIDI-файл
with open("simple_melody.mid", "wb") as output_file:
    midi.writeFile(output_file)

print("Готово! Файл 'simple_melody.mid' создан.")

### Как использовать:
1. Установите библиотеку MIDIUtil (если она ещё не установлена):

   pip install MIDIUtil
   

2. Запустите скрипт. Он создаст файл simple_melody.mid в текущей директории.
3. Откройте файл в любой MIDI-плеере или музыкальном редакторе, например, в MuseScore или GarageBand.

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

Для генерации музыки в стиле Disco 80-х можно использовать синкопированные басы, четкий ритм, и яркие аккорды. Мы будем создавать MIDI-файл с басовой линией, ритмом и аккордами. Вот пример кода:

### Код генерации MIDI-файла в стиле Disco 80-х

from midiutil import MIDIFile

# Создаем объект MIDI-файла
midi = MIDIFile(1)  # Один трек
track = 0
time = 0
channel = 0
volume = 100

# Устанавливаем темп и название трека
midi.addTrackName(track, time, "Disco 80s")
midi.addTempo(track, time, 120)  # 120 BPM, типично для диско

# Басовая линия
bass_notes = [
    (36, 0, 0.5), (36, 0.5, 0.5), (38, 1, 0.5), (38, 1.5, 0.5),  # C и D
    (40, 2, 0.5), (40, 2.5, 0.5), (38, 3, 0.5), (38, 3.5, 0.5),  # E и D
]

# Добавляем басовые ноты
for note, start_time, duration in bass_notes * 4:  # Повторяем 4 раза
    midi.addNote(track, channel, note, start_time, duration, volume)

# Аккорды
chords = [
    (60, 0, 1), (64, 0, 1), (67, 0, 1),  # C major (C, E, G)
    (62, 1, 1), (65, 1, 1), (69, 1, 1),  # D minor (D, F, A)
    (60, 2, 1), (64, 2, 1), (67, 2, 1),  # C major
    (57, 3, 1), (60, 3, 1), (64, 3, 1),  # A minor (A, C, E)
]

# Добавляем аккорды
for note, start_time, duration in chords:
    midi.addNote(track, channel, note, start_time, duration, volume - 20)

# Ритмический рисунок
drums = [
    (35, 0, 0.25), (42, 0.5, 0.25), (35, 1, 0.25), (42, 1.5, 0.25),  # Kick и Hi-hat
    (35, 2, 0.25), (42, 2.5, 0.25), (35, 3, 0.25), (42, 3.5, 0.25),  # Повтор
]

# Добавляем ударные (на канал 9, типичный для перкуссии)
for note, start_time, duration in drums * 4:  # Повторяем 4 раза
    midi.addNote(track, 9, note, start_time, duration, volume)

# Сохраняем MIDI-файл
with open("disco_80s.mid", "wb") as output_file:
    midi.writeFile(output_file)

print("Готово! Файл 'disco_80s.mid' создан.")

### Особенности:
1. Басовая линия: Короткие, ритмичные ноты создают основу.
2. Аккорды: Простые мажорные и минорные аккорды в верхнем регистре для "яркости".
3. Ударные: Kick и Hi-hat для типичного диско-звучания.

### Как использовать:
1. Установите MIDIUtil, если она еще не установлена:

   pip install MIDIUtil
   

2. Запустите код. Файл disco_80s.mid появится в текущей директории.
3. Откройте файл в MIDI-редакторе, таком как MuseScore, чтобы послушать или доработать.

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

👉 На Python пишут сайты, приложения, игры и чат-боты Например, Sims 4 и Dropbox написаны на Python 🤨

👉 Живые онлайн-занятия в мини-группах 🤔

👉 На курсе с вами будут работать преподаватели 🧐

👉 Командный проект: практический опыт совместной разработки 🤝

👉 Поможем найти работу или вернем деньги 💰

🔥🔥🔥 Подключайтесь к курсу Профессия Python-разработчик от GeekBrains 🔥🔥🔥

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

Пример кода на Python для распознавания лиц (face recognition)

---

Шаг 1. Установка необходимых библиотек

pip install cmake
pip install dlib
pip install face_recognition
pip install opencv-python

> *Примечание:*
> - dlib может потребовать установки дополнительных зависимостей (в зависимости от вашей ОС).
> - Если у вас возникают трудности, посмотрите официальную [документацию](https://pypi.org/project/face_recognition/).

---

Шаг 2. Подготовка изображений для обучения
Чтобы распознавать конкретного человека, вам нужно:
1. Иметь одну или несколько фотографий этого человека.
2. Считать их в коде и получить *encoding* (цифровое представление лица).

Например, у нас есть два файла с изображениями:
- person1.jpg — фотография человека A
- person2.jpg — фотография человека B

---

Шаг 3. Пример кода

import face_recognition
import cv2

# Загружаем изображения и получаем face encodings
person1_image = face_recognition.load_image_file("person1.jpg")
person1_encoding = face_recognition.face_encodings(person1_image)[0]

person2_image = face_recognition.load_image_file("person2.jpg")
person2_encoding = face_recognition.face_encodings(person2_image)[0]

# Список известных лиц и их имён
known_encodings = [
    person1_encoding,
    person2_encoding
]
known_names = [
    "Person 1",
    "Person 2"
]

# Инициализируем веб-камеру
video_capture = cv2.VideoCapture(0)

while True:
    # Считываем кадр с веб-камеры
    ret, frame = video_capture.read()
    if not ret:
        break

    # Преобразуем кадр из BGR (OpenCV) в RGB (face_recognition)
    rgb_frame = frame[:, :, ::-1]

    # Находим все лица и их encodings в текущем кадре
    face_locations = face_recognition.face_locations(rgb_frame)
    face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)

    for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
        # Сравниваем лицо с известными лицами
        matches = face_recognition.compare_faces(known_encodings, face_encoding)
        name = "Unknown"

        # Выбираем лицо с наименьшей дистанцией
        face_distances = face_recognition.face_distance(known_encodings, face_encoding)
        best_match_index = min(range(len(face_distances)), key=lambda i: face_distances[i])
        
        if matches[best_match_index]:
            name = known_names[best_match_index]

        # Рисуем прямоугольник вокруг лица
        cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)
        # Подпись имени
        cv2.rectangle(frame, (left, bottom - 25), (right, bottom), (0, 255, 0), cv2.FILLED)
        cv2.putText(frame, name, (left + 6, bottom - 6), cv2.FONT_HERSHEY_DUPLEX, 0.6, (0, 0, 0), 1)

    # Показываем результат
    cv2.imshow('Face Recognition', frame)

    # Нажмите 'q', чтобы выйти
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Освобождаем ресурсы
video_capture.release()
cv2.destroyAllWindows()

---

Как это работает
1. face_recognition.load_image_file("person1.jpg") — загружает изображение в формате numpy-массива.
2. face_recognition.face_encodings(...) — вычисляет цифровое представление (encoding) лица.
3. В цикле происходит:
- Чтение кадра с веб-камеры.
- Поиск лиц (`face_locations`) и вычисление их encodings (`face_encodings`).
- Сравнение полученных encodings с известными лицами при помощи compare_faces.
- Если найдено совпадение, отображается имя, в противном случае — "Unknown".

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

Распознавание зевка с помощью Python и dlib
В данной статье рассмотрим простой метод определения момента зевка, используя компьютерное зрение (OpenCV) и библиотеку dlib. Основная идея — следить за тем, насколько широко открыт рот у человека, который попал в кадр.

### 1. Установка зависимостей

pip install opencv-python dlib

Кроме того, нужно скачать предобученный детектор лицевых лэндмарок:
[shape_predictor_68_face_landmarks.dat](http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2)
Разархивируйте его и разместите в рабочей директории.

### 2. Общая идея

1. Детектируем лицо с помощью dlib.get_frontal_face_detector().
2. Находим ключевые точки (landmarks) лица с помощью shape_predictor_68_face_landmarks.dat.
3. Вычисляем Mouth Aspect Ratio (MAR) — отношение вертикальных расстояний между верхними и нижними точками рта к горизонтальному расстоянию.
4. Если MAR превышает некоторый порог (например, 0.6), считаем, что человек зевает.

### 3. Пример кода

import cv2
import dlib
import math

# Инициализация детектора лиц и предсказателя ключевых точек
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")

def mouth_aspect_ratio(landmarks):
    # Индексы точек рта в 68-точечной модели (60...67)
    mouth_points = [60, 61, 62, 63, 64, 65, 66, 67]
    
    # Вычисляем расстояния между верхней и нижней губами
    dist1 = math.dist(landmarks[mouth_points[1]], landmarks[mouth_points[7]])
    dist2 = math.dist(landmarks[mouth_points[2]], landmarks[mouth_points[6]])
    
    # Горизонтальное расстояние между левым и правым уголками рта
    dist_horizontal = math.dist(landmarks[mouth_points[0]], landmarks[mouth_points[4]])
    
    # MAR = (dist1 + dist2) / (2.0 * dist_horizontal)
    return (dist1 + dist2) / (2.0 * dist_horizontal)

# Порог, выше которого считаем, что идёт зевок
MAR_THRESHOLD = 0.6

# Запуск веб-камеры
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = detector(gray)

    for face in faces:
        # Предсказываем расположение 68 ключевых точек лица
        shape = predictor(gray, face)
        # Конвертируем их в список (x, y)
        landmarks = [(shape.part(i).x, shape.part(i).y) for i in range(68)]
        
        mar = mouth_aspect_ratio(landmarks)
        
        # Выводим MAR на экран
        cv2.putText(frame, f"MAR: {mar:.2f}", (30, 30),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
        
        # Если MAR превышает порог, выводим предупреждение о зевке
        if mar > MAR_THRESHOLD:
            cv2.putText(frame, "YAWN DETECTED", (30, 70),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 3)
    
    # Отображаем результат
    cv2.imshow("Yawn Detection", frame)
    
    # Нажмите 'q' для выхода
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

### 4. Как это работает

1. Поиск лица: detector(gray) возвращает координаты прямоугольника, в котором находится лицо.
2. Определение лэндмарок: predictor(...) для каждого лица возвращает 68 ключевых точек.
3. Расчёт MAR: функция mouth_aspect_ratio измеряет расстояния между точками рта. При зевке рот широко раскрыт, и показатель растёт.
4. Сравнение с порогом: если MAR выше 0.6 (на практике этот порог можно подобрать экспериментально), выводим предупреждение.

Таким образом, с помощью Python, OpenCV и dlib можно в режиме реального времени определять зевок по тому, насколько широко открыт рот у человека. Данный подход можно адаптировать и усложнить (например, учитывать последовательность кадров, минимизировать ложные срабатывания), но даже в базовом варианте он хорошо демонстрирует работу с распознаванием ключевых точек лица.

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

Профессия Python-разработчик от GeekBrains ждет Вас 🤓🤓🤓

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

Пример реализации низкочастотного аудиофильтра (Butterworth) на Python

Ниже рассмотрим, как спроектировать и применить низкочастотный фильтр (Low-Pass Filter) на основе **Butterworth**-подхода при помощи scipy.signal.

### 1. Установка необходимых библиотек

pip install numpy scipy

### 2. Общая идея Butterworth-фильтра

- Butterworth-фильтр даёт максимально плоскую амплитудно-частотную характеристику в полосе пропускания без ряби.
- Описание фильтра задаётся:
1. Порядком фильтра \( N \).
2. Нормированной частотой среза \( Wn \) (от 0 до 1, где 1 соответствует половине частоты дискретизации).

### 3. Пример кода

Допустим, у нас есть файл input.wav. Нужно отфильтровать высокие частоты и сохранить результат в output.wav.

import numpy as np
from scipy.io import wavfile
from scipy.signal import butter, filtfilt

def butter_lowpass_filter(data, cutoff_freq, fs, order=4):
    """
    Создаёт и применяет Butterworth-фильтр низких частот.
    :param data: аудиосигнал (numpy-массив)
    :param cutoff_freq: частота среза (Гц)
    :param fs: частота дискретизации (Гц)
    :param order: порядок фильтра
    :return: отфильтрованный сигнал
    """
    # Нормируем частоту среза (Nyquist = fs/2)
    nyquist = 0.5 * fs
    normal_cutoff = cutoff_freq / nyquist
    
    # Создаём параметры фильтра
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    
    # Применяем фильтр к сигналу
    filtered_data = filtfilt(b, a, data)
    return filtered_data

# --- Демонстрация ---
if __name__ == "__main__":
    # 1. Считываем исходный wav
    fs, data = wavfile.read("input.wav")  # fs - частота дискретизации

    # Если многоканальный сигнал (стерео), выберем один канал или применим фильтр к каждому
    if data.ndim > 1:
        data = data[:, 0]  # допустим, берём левый канал

    # 2. Применяем низкочастотный фильтр
    cutoff = 3000.0  # Частота среза, Гц
    filtered = butter_lowpass_filter(data, cutoff, fs, order=4)

    # 3. Сохраняем результат в новый wav-файл
    # Приведём тип данных (например, обратно к int16 при условии не слишком больших амплитуд)
    filtered_int16 = np.int16(filtered / np.max(np.abs(filtered)) * 32767)
    wavfile.write("output.wav", fs, filtered_int16)

### 4. Комментарии

1. Частота среза должна лежать ниже половины частоты дискретизации (Nyquist).
2. Порядок фильтра (4–6) обычно даёт разумный баланс между крутизной среза и фазовыми искажениями.
3. Функция filtfilt минимизирует фазовые искажения, пропуская сигнал через фильтр вперёд и назад.
4. При сохранении в wav важно масштабировать выходные данные под нужный тип (например, `int16`).

Такой алгоритм Butterworth-фильтра зачастую используют для снижения высокочастотных шумов в аудиозаписях. При необходимости можно спроектировать фильтры другого типа (high-pass, band-pass) или применить другие методы (например, FIR-фильтры с использованием оконных функций).

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

Backtracking на примере задачи о ферзях (N-Queens)

Задача: расставить \( N \) ферзей на шахматной доске размером \( N \times N \) так, чтобы ни один ферзь не бил другого. То есть никакие два ферзя не должны находиться в одном столбце, строке или диагонали.


### 1. Общая идея Backtracking

1. Рекурсивно пытаемся поставить ферзя в каждой доступной ячейке текущей строки.
2. Проверяем не возникает ли конфликта с уже установленными ферзями.
3. Если конфликт есть, откатываемся и пробуем следующую позицию.
4. Если ферзь успешно установлен в текущей строке, переходим к следующей.
5. Когда расставлены ферзи во всех \( N \) строках, получаем одно из возможных решений.

### 2. Пример кода на Python

def solveNQueens(n):
    """
    Возвращает все возможные способы расставить n ферзей на n×n доске.
    Каждое решение представлено списком строк, где 'Q' обозначает ферзя, '.' - пустую клетку.
    """
    solutions = []
    board = [-1] * n  # board[r] = колонка, в которой стоит ферзь в строке r

    def can_place(row, col):
        # Проверяем, не бьёт ли новый ферзь уже расставленных
        for r in range(row):
            c = board[r]
            if c == col or abs(c - col) == abs(r - row):
                return False
        return True

    def backtrack(row=0):
        if row == n:
            # Все ферзи расставлены, формируем решение в виде строк
            one_solution = []
            for r in range(n):
                row_str = '.' * board[r] + 'Q' + '.' * (n - board[r] - 1)
                one_solution.append(row_str)
            solutions.append(one_solution)
        else:
            # Перебираем все возможные колонки для текущей строки
            for col in range(n):
                if can_place(row, col):
                    board[row] = col
                    backtrack(row + 1)

    backtrack()
    return solutions

# --- Демонстрация ---
if __name__ == "__main__":
    n = 4
    results = solveNQueens(n)
    print(f"Число решений для {n}-ферзей: {len(results)}")
    for sol in results:
        for row in sol:
            print(row)
        print()

### 3. Как это работает

1. Массив board хранит позиции ферзей: board[r] равен индексу столбца, где находится ферзь в строке r.
2. Функция can_place(row, col) проверяет, не атакует ли новый ферзь уже установленных.
3. Рекурсивная функция backtrack(row) пытается поставить ферзя в строку row. Если получилось расставить ферзей во всех строках (до `row == n`), решение добавляется в общий список.
4. За счёт отката (backtracking) мы перебираем все варианты: при первом конфликте с уже установленным ферзём переносим ферзя в другую колонку.

Итог: Backtracking позволяет эффективно обходить все допустимые расположения, при этом отбрасывая те, что явно приводят к конфликту, ещё на ранних шагах.

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

Клеточные автоматы на примере Conway's Game of Life

_Conway's Game of Life_ — классический клеточный автомат, где каждая клетка живёт или умирает по простым правилам:

1. Живая клетка с 2 или 3 живыми соседями остаётся живой, иначе умирает.
2. Мёртвая клетка с ровно 3 живыми соседями становится живой.
3. Во всех остальных случаях состояние клетки не меняется или она остаётся мёртвой.

Ниже приведён простой код на Python, моделирующий данную игру с помощью библиотеки matplotlib для визуализации.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

def update(frame_num, img, grid, N):
    new_grid = grid.copy()

    for i in range(N):
        for j in range(N):
            # Считаем количество живых соседей
            total = int(
                grid[(i - 1) % N, (j - 1) % N] + grid[(i - 1) % N, j] + grid[(i - 1) % N, (j + 1) % N] +
                grid[i, (j - 1) % N] +                                     grid[i, (j + 1) % N] +
                grid[(i + 1) % N, (j - 1) % N] + grid[(i + 1) % N, j] + grid[(i + 1) % N, (j + 1) % N]
            )
            # Применяем правила
            if grid[i, j] == 1:  # Живая
                if total < 2 or total > 3:
                    new_grid[i, j] = 0
            else:  # Мёртвая
                if total == 3:
                    new_grid[i, j] = 1

    img.set_data(new_grid)
    grid[:] = new_grid[:]
    return [img]

def main():
    N = 50  # размер поля NxN
    # Инициализируем сетку случайными 0 и 1
    grid = np.random.choice([0, 1], N*N, p=[0.8, 0.2]).reshape(N, N)

    fig, ax = plt.subplots()
    img = ax.imshow(grid, interpolation='nearest', cmap='binary')
    ani = animation.FuncAnimation(
        fig, update, fargs=(img, grid, N),
        frames=100, interval=100, save_count=50, blit=True
    )
    plt.show()

if __name__ == "__main__":
    main()

### Как это работает

1. Сетка grid — двумерный массив, в каждой ячейке которого 0 (мёртвая клетка) или 1 (живая клетка).
2. На каждом шаге (`update`) для каждой клетки подсчитываются 8 соседей (с учётом периодических краёв через операцию `% N`).
3. Применяются правила (2–3 живых соседа — выживание, ровно 3 соседа — зарождение).
4. matplotlib.animation.FuncAnimation каждую итерацию вызывает update, перерисовывая текущее состояние сетки.

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

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

Сжатие данных на примере алгоритма Хаффмана (Huffman Coding)

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


### 1. Основная идея

1. Подсчёт частот: Сколько раз каждый символ встречается во входных данных.
2. Построение дерева: Создаём дерево Хаффмана, соединяя самые редкие символы в листьях с меньшими «весами» (их суммарной частотой).
3. Назначение кодов: Проходя от корня к листьям, формируем бинарные коды (левый переход, например, 0, правый — `1`).
4. Сжатие: Заменяем каждый символ его битовым кодом.

### 2. Пример кода на Python

from heapq import heappush, heappop

# Узел дерева Хаффмана
class Node:
    def __init__(self, char, freq, left=None, right=None):
        self.char = char
        self.freq = freq
        self.left = left
        self.right = right
    
    # Для сравнения в куче
    def __lt__(self, other):
        return self.freq < other.freq

def build_huffman_tree(freqs):
    """
    Создаёт дерево Хаффмана на основе словаря {символ: частота}.
    Возвращает корень дерева.
    """
    heap = []
    for ch, fr in freqs.items():
        heappush(heap, Node(ch, fr))
    
    # Сливаем узлы, пока не останется один
    while len(heap) > 1:
        left = heappop(heap)
        right = heappop(heap)
        merged = Node(None, left.freq + right.freq, left, right)
        heappush(heap, merged)
    
    return heap[0] if heap else None

def build_codes(root):
    """
    Обходит дерево Хаффмана и строит словарь {символ: код}.
    """
    codes = {}
    
    def traverse(node, prefix=""):
        if not node:
            return
        if node.char is not None:
            codes[node.char] = prefix
            return
        traverse(node.left, prefix + "0")
        traverse(node.right, prefix + "1")
    
    traverse(root)
    return codes

def huffman_compress(text):
    # 1) Считаем частоты
    freqs = {}
    for ch in text:
        freqs[ch] = freqs.get(ch, 0) + 1
    
    # 2) Строим дерево
    root = build_huffman_tree(freqs)
    # 3) Генерируем коды
    codes = build_codes(root)
    # 4) Кодируем текст
    encoded = "".join(codes[ch] for ch in text)
    
    return encoded, codes

def huffman_decompress(encoded, codes):
    # Создаём словарь {код: символ}
    reverse_codes = {v: k for k, v in codes.items()}
    decoded = ""
    prefix = ""
    for bit in encoded:
        prefix += bit
        if prefix in reverse_codes:
            decoded += reverse_codes[prefix]
            prefix = ""
    return decoded

# --- Демонстрация ---
if __name__ == "__main__":
    original_text = "hello huffman compression!"
    print("Оригинальный текст:", original_text)

    # Сжимаем
    compressed_data, code_map = huffman_compress(original_text)
    print("Сжатые данные (биты):", compressed_data)

    # Распаковываем
    decompressed_data = huffman_decompress(compressed_data, code_map)
    print("Распакованный текст:", decompressed_data)

### 3. Принцип работы кратко
1. build_huffman_tree: складываем все символы в мин-кучу (heap), затем берём два узла с наименьшей частотой, объединяем их в новый узел, возвращаем в кучу. Повторяем, пока не останется единственный корень.
2. build_codes: рекурсивный обход дерева; левые переходы получают 0, правые — 1. Листу (символу) назначается накопленный префикс.
3. huffman_compress: заменяем каждый символ его бинарным кодом — получаем битовую строку.
4. huffman_decompress: идём по битам, проверяем промежуточные префиксы в reverse_codes, как только совпало, добавляем найденный символ.

Таким образом, алгоритм Хаффмана позволяет эффективно сжимать данные, давая более короткие коды часто встречающимся символам и более длинные — редким.

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

Пример использования OpenCV для распознавания граней (Edge Detection) с помощью оператора Канни (Canny)

Ниже приведён пример кода на Python, демонстрирующий базовую обработку изображения и выделение граней (контуров) с использованием библиотеки OpenCV.

### 1. Установка необходимых библиотек

pip install opencv-python

### 2. Пример кода

import cv2
import numpy as np

def canny_edge_detection(image_path):
    # Загружаем изображение в оттенках серого
    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    if image is None:
        raise ValueError("Не удалось загрузить изображение. Проверьте путь.")

    # Шумоподавление с помощью GaussianBlur
    blurred = cv2.GaussianBlur(image, (5, 5), 1.4)

    # Применяем оператор Канни
    edges = cv2.Canny(blurred, threshold1=50, threshold2=150)

    return image, edges

if __name__ == "__main__":
    input_image = "sample.jpg"  # Путь к исходному изображению

    original, edges = canny_edge_detection(input_image)

    # Отображаем результаты
    cv2.imshow("Original", original)
    cv2.imshow("Canny Edges", edges)

    # Нажмите любую клавишу, чтобы закрыть окна
    cv2.waitKey(0)
    cv2.destroyAllWindows()

### 3. Как это работает

1. Чтение изображения: cv2.imread(..., cv2.IMREAD_GRAYSCALE) переводит картинку в градации серого.
2. Размытие (GaussianBlur): уменьшает шум, улучшая результат оператора Канни.
3. Оператор Канни: выделяет границы, вычисляя градиенты яркости. Параметры threshold1 и threshold2 задают нижний и верхний пороги.
4. Отображение: с помощью cv2.imshow можно посмотреть исходное изображение и полученную карту границ.

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

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

Почему в феврале иногда 29, а иногда 28 дней?

Дело в високосных годах. По григорианскому календарю год является високосным, если:
1. Делится на 4 без остатка;
2. При этом не делится на 100, кроме случаев, когда делится на 400.

Таким образом:
- Годы, кратные 4, обычно високосные (февраль = 29 дней).
- Но если год делится на 100 (например, 1900), то он не високосный (февраль = 28 дней), если только не делится на 400 (например, 2000 — високосный).

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

def is_leap_year(year: int) -> bool:
    """
    Возвращает True, если год 'year' високосный, иначе False.
    """
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

def days_in_february(year: int) -> int:
    """
    Возвращает количество дней в феврале для заданного года.
    """
    return 29 if is_leap_year(year) else 28

if __name__ == "__main__":
    years_to_test = [2020, 2021, 2022, 2023, 2024, 1900, 2000]

    for y in years_to_test:
        print(f"Год {y}: февраль имеет {days_in_february(y)} дней. "
              f"Високосный? {is_leap_year(y)}")

### Объяснение
1. is_leap_year: проверяет правила деления на 4, 100 и 400.
2. days_in_february: если год високосный, возвращаем 29, иначе 28.
3. В конце тестируем на нескольких годах:
- 2020 (делится на 4 и не на 100) → високосный, февраль 29;
- 1900 (делится на 100, но не на 400) → не високосный, февраль 28;
- 2000 (делится на 400) → високосный, февраль 29.

Так мы наглядно видим, почему в феврале может быть как 28, так и 29 дней.

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

Пример преобразований (Conversions) на Python: перевод чисел между различными системами счисления

В данном примере рассмотрим, как конвертировать целые числа в различные системы счисления (двоичную, восьмеричную и шестнадцатеричную), а также обратно — в десятичную.

### 1. Прямой перевод (из десятичной в другие системы счисления)

Python предоставляет встроенные функции:
- bin(x) — возвращает строку вида '0b...' (двоичное представление).
- oct(x) — возвращает строку вида '0o...' (восьмеричное представление).
- hex(x) — возвращает строку вида '0x...' (шестнадцатеричное представление).

num = 255

binary_repr = bin(num)    # '0b11111111'
octal_repr = oct(num)     # '0o377'
hex_repr = hex(num)       # '0xff'

print("Десятичное:", num)
print("Двоичное:", binary_repr)
print("Восьмеричное:", octal_repr)
print("Шестнадцатеричное:", hex_repr)

> При желании можно убрать префиксы 0b, 0o, 0x, если оставить только часть строки после первых двух символов.

### 2. Обратный перевод (из строки в десятичное число)

Для преобразования строки в число используем функцию int(строка, основание). Второй параметр указывает на основание системы счисления.

binary_str = "11111111"
octal_str = "377"
hex_str = "ff"

dec_from_bin = int(binary_str, 2)  # 255
dec_from_oct = int(octal_str, 😍  # 255
dec_from_hex = int(hex_str, 16)   # 255

print("Из двоичной:", dec_from_bin)
print("Из восьмеричной:", dec_from_oct)
print("Из шестнадцатеричной:", dec_from_hex)

### 3. Пример функции перевода в любую систему счисления

Если нужно явно сконвертировать число в систему счисления с основанием base (2..36) без встроенных префиксов, можно написать свою функцию:

def to_base(num, base=2):
    """Переводит целое число num в систему счисления base (2..36). Возвращает строку."""
    if num == 0:
        return "0"
    
    digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    result = ""
    is_negative = (num < 0)
    num = abs(num)

    while num > 0:
        remainder = num % base
        result = digits[remainder] + result
        num //= base

    if is_negative:
        result = "-" + result

    return result

# Проверка работы:
print(to_base(255, 2))   # '11111111'
print(to_base(255, 8))   # '377'
print(to_base(255, 16))  # 'FF'

### 4. Вывод

Таким образом, в Python легко работать с различными системами счисления:
- Встроенные функции bin, oct, hex и int(..., base) покрывают большинство задач.
- Пользовательская функция позволяет гибко настраивать основание системы счисления и формат вывода.

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

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