Распознавание зевка с помощью 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 🤖

Вот пример на Python, который в реальном времени отслеживает цены на криптовалюты с помощью API. Пример включает визуальные элементы в виде эмодзи и цветовое форматирование в терминале.

import requests
import time
from datetime import datetime

def get_crypto_prices():
    symbols = {
        'bitcoin': '₿',
        'ethereum': 'Ξ',
        'dogecoin': 'Ð'
    }
    
    try:
        response = requests.get(
            'https://api.coingecko.com/api/v3/simple/price',
            params={
                'ids': ','.join(symbols.keys()),
                'vs_currencies': 'usd',
                'include_market_cap': 'true',
                'include_24hr_change': 'true'
            }
        )
        data = response.json()
        
        print(f"\n{'🚀 Crypto Tracker':^50}")
        print(f"{'='*50}")
        
        for crypto, values in data.items():
            emoji = symbols[crypto]
            price = values['usd']
            change = values['usd_24h_change']
            change_color = '\033[92m' if change >=0 else '\033[91m'
            
            print(f"{emoji} {crypto.capitalize():<12}"
                  f"|\033[94m ${price:>9,.2f}\033[0m "
                  f"| 24h: {change_color}{change:>+6.2f}%\033[0m")
            
        print(f"\nLast update: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        
    except Exception as e:
        print(f"🔴 Error fetching data: {e}")

if __name__ == "__main__":
    while True:
        get_crypto_prices()
        try:
            time.sleep(30)  # Update every 30 seconds
        except KeyboardInterrupt:
            print("\n👋 Exiting crypto tracker...")
            break

Особенности, включённые в этот код:

* Отслеживание цен на криптовалюты в режиме реального времени с помощью API CoinGecko.
* Визуализация различных монет с помощью эмодзи.
* Цветовое кодирование процентных изменений (зелёный/красный).
* Форматирование рыночных данных с использованием запятых.
* Автоматическое обновление каждые 30 секунд.
* Очистка вывода терминала с отметкой времени.
* Обработка ошибок.
* Поддержка прерывания клавиатуры.

Чтобы запустить этот код:
* Установите необходимый пакет: pip install requests.
* Запустите скрипт в терминале/CMD.
* Нажмите Ctrl+C для выхода.

Скрипт отобразит:
* Текущие цены.
* Процентные изменения за 24 часа.
* Рыночную капитализацию.
* Данные будут автоматически обновляться каждые 30 секунд.

Этот скрипт сочетает в себе несколько модных элементов: криптовалюту, интеграцию API, данные в реальном времени и визуальное форматирование в терминале! 🚀

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

Криптотерминал из кода выше 👆👆👆

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

Пример алгоритма компьютерного зрения на Python с использованием OpenCV и NumPy. Этот код выполняет обнаружение краев на изображении с помощью оператора Кэнни:

import cv2
import numpy as np

def process_image(image_path):
    # Загружаем изображение
    image = cv2.imread(image_path, cv2.IMREAD_COLOR)
    if image is None:
        print("Ошибка: не удалось загрузить изображение.")
        return
    
    # Преобразуем изображение в оттенки серого
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Применяем размытие для снижения шума
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # Выполняем обнаружение краев методом Кэнни
    edges = cv2.Canny(blurred, 50, 150)
    
    # Показываем результат
    cv2.imshow('Original Image', image)
    cv2.imshow('Edge Detection', edges)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# Укажите путь к изображению
image_path = 'example.jpg'  # Замените на путь к вашему изображению
process_image(image_path)

Этот алгоритм:
1. Загружает изображение.
2. Конвертирует его в градации серого.
3. Применяет размытие для уменьшения шумов.
4. Выполняет обнаружение краев методом Кэнни.
5. Отображает исходное изображение и обработанный результат.

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

Прикольный алгоритм с использованием структуры данных Очередь (Queue) для управления очередью в ночном клубе! 🎉

Ситуация:
Представьте, что вы управляете входом в популярный ночной клуб. У вас есть ограниченное количество мест, и вам нужно следить за тем, чтобы люди заходили в порядке живой очереди. При этом VIP-гости должны обслуживаться быстрее.

Решение:
Мы используем две очереди (обычную и приоритетную), чтобы справедливо распределять доступ.

Код на Python

from collections import deque
import time

class NightClubQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.regular_queue = deque()  # Очередь для обычных посетителей
        self.vip_queue = deque()  # Очередь для VIP

    def arrive(self, name, is_vip=False):
        if is_vip:
            self.vip_queue.append(name)
            print(f"🔥 VIP {name} добавлен в VIP-очередь!")
        else:
            self.regular_queue.append(name)
            print(f"🕺 {name} встал в обычную очередь!")

    def admit_guest(self):
        if len(self.vip_queue) > 0:
            guest = self.vip_queue.popleft()
            print(f"🚀 Пропускаем VIP {guest}!")
        elif len(self.regular_queue) > 0:
            guest = self.regular_queue.popleft()
            print(f"✅ Пропускаем обычного гостя {guest}!")
        else:
            print("⏳ Очередь пуста, можно отдыхать!")

    def run_night(self):
        print("\n🎶 Начинаем вечер в клубе! 🎶\n")
        while self.vip_queue or self.regular_queue:
            self.admit_guest()
            time.sleep(1)  # Имитация задержки при входе
        print("\n🎉 Вход завершен, клуб заполнен!\n")

# Пример использования
club = NightClubQueue(capacity=5)
club.arrive("Иван")
club.arrive("Алина", is_vip=True)
club.arrive("Дмитрий")
club.arrive("Сергей", is_vip=True)
club.arrive("Мария")

club.run_night()

Как это работает?
1. Добавляем людей в две очереди:
- VIP-гости попадают в vip_queue.
- Обычные посетители – в regular_queue.
2. При входе в клуб приоритет отдается VIP-гостям.
3. Гости заходят по очереди, пока клуб не заполнится.
4. Клуб закрывается, когда все вошли.

### Реальное применение
Этот алгоритм можно использовать в:
- Управлении живыми очередями (концерты, аэропорты 🛫, мероприятия 🎭).
- Разработке онлайн-систем бронирования, где премиум-клиенты получают приоритет.
- Виртуальных очередях (например, при покупке билетов 🎟).

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