Mesh ракета по коду выше 👆👆👆

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

Запили новый визуал для нашего софта сканирования помещений в CAD 🙂 Не смог не поделится такой красотой 🔥

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

Пример простого кода игры на PyGame, где игрок управляет квадратом, избегая движущихся препятствий:

### Установка PyGame
Если у вас не установлен PyGame, выполните команду:

pip install pygame

### Код для игры

import pygame
import random
import sys

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

# Настройки окна
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Простая игра на PyGame")

# Цвета
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)

# Переменные игрока
player_size = 50
player_x = WIDTH // 2
player_y = HEIGHT - 2 * player_size
player_speed = 10

# Препятствия
enemy_size = 50
enemy_x = random.randint(0, WIDTH - enemy_size)
enemy_y = 0
enemy_speed = 5

# Счёт
score = 0
font = pygame.font.Font(None, 36)

# Основной игровой цикл
clock = pygame.time.Clock()
running = True
while running:
    screen.fill(WHITE)

    # Обработка событий
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Движение игрока
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_x > 0:
        player_x -= player_speed
    if keys[pygame.K_RIGHT] and player_x < WIDTH - player_size:
        player_x += player_speed

    # Движение препятствия
    enemy_y += enemy_speed
    if enemy_y > HEIGHT:
        enemy_y = 0
        enemy_x = random.randint(0, WIDTH - enemy_size)
        score += 1  # Увеличение счёта

    # Проверка столкновений
    if (
        player_x < enemy_x + enemy_size
        and player_x + player_size > enemy_x
        and player_y < enemy_y + enemy_size
        and player_y + player_size > enemy_y
    ):
        running = False  # Игра заканчивается при столкновении

    # Рисование игрока и препятствия
    pygame.draw.rect(screen, GREEN, (player_x, player_y, player_size, player_size))
    pygame.draw.rect(screen, RED, (enemy_x, enemy_y, enemy_size, enemy_size))

    # Отображение счёта
    score_text = font.render(f"Счёт: {score}", True, BLACK)
    screen.blit(score_text, (10, 10))

    # Обновление экрана
    pygame.display.flip()
    clock.tick(30)  # FPS

# Завершение игры
pygame.quit()
sys.exit()

---

### Как работает игра:
1. Игрок управляет зелёным квадратом с помощью клавиш ← и →.
2. Красный квадрат (препятствие) падает сверху вниз.
3. Если игрок избегает препятствия, счёт увеличивается.
4. Если происходит столкновение, игра завершается.

---

### Как улучшить:
1. Добавить уровни сложности:
- Увеличивать скорость препятствий по мере роста счёта.
2. Множество препятствий:
- Добавить несколько красных квадратов с разными скоростями.
3. Звуковые эффекты:
- Добавить звуки при столкновении или при наборе очков.

   collision_sound = pygame.mixer.Sound("collision.wav")
   collision_sound.play()
   

4. Меню и перезапуск игры.

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

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

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

Отвечаем на все вопросы в курсах 👍 Радуемся лайкам и решениям студентов на курсах 😃😃😃

Три наших самых популярных курса на Stepik:

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

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

👉 Python в нескучных примерах (50) 🔥

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

Для генерации цветов на День Святого Валентина можно использовать библиотеку turtle, которая позволяет рисовать графику на основе команд. Ниже приведен пример кода для рисования романтических цветов:

import turtle
import random

def draw_flower(x, y, petal_color, center_color):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()

    # Рисуем лепестки
    turtle.color(petal_color)
    for _ in range(6):  # 6 лепестков
        turtle.begin_fill()
        turtle.circle(20, steps=3)  # Треугольные лепестки
        turtle.end_fill()
        turtle.right(60)  # Угол между лепестками

    # Рисуем центр цветка
    turtle.penup()
    turtle.goto(x, y - 10)
    turtle.pendown()
    turtle.color(center_color)
    turtle.begin_fill()
    turtle.circle(10)
    turtle.end_fill()

def draw_stem(x, y):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()

    # Рисуем стебель
    turtle.color("green")
    turtle.width(3)
    turtle.right(90)
    turtle.forward(50)

    # Рисуем лист
    turtle.penup()
    turtle.goto(x, y - 25)
    turtle.pendown()
    turtle.begin_fill()
    turtle.left(45)
    turtle.circle(10, 180)
    turtle.right(90)
    turtle.circle(10, 180)
    turtle.left(45)
    turtle.end_fill()

# Настройка экрана
turtle.setup(width=800, height=600)
turtle.speed(0)
turtle.hideturtle()
turtle.bgcolor("pink")

# Генерация цветов
for _ in range(10):
    x = random.randint(-300, 300)
    y = random.randint(-200, 200)
    petal_color = random.choice(["red", "yellow", "blue", "purple", "orange"])
    center_color = "yellow"

    draw_flower(x, y, petal_color, center_color)
    draw_stem(x, y - 20)

# Показать результат
turtle.done()

### Описание кода:
1. Цветы:
- Цветы состоят из шести лепестков, нарисованных кругами.
- Центр цветка — маленький желтый круг.
2. Стебель:
- Зелёный стебель с листиком сбоку.
3. Случайное размещение:
- Цветы размещаются в случайных позициях на экране.
4. Цвета лепестков:
- Лепестки окрашиваются в случайные яркие цвета: красный, жёлтый, синий и другие.

---

### Как использовать:
1. Скопируйте код в файл flowers.py.
2. Запустите его в Python.
3. На экране появится множество случайно размещённых цветов.

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

Код генерации цветов выше 👆👆👆

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

Создание простой 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 🤖