Справочник Программиста

import shutil
from pathlib import Path


def sort_files_by_type(folder_path):
    # Преобразуем путь к папке в объект Path
    folder = Path(folder_path)

    # Проверяем, существует ли папка и является ли она директорией
    if not folder.exists() or not folder.is_dir():
        print("Указанная папка не существует или это не папка.")
        return

    # Перебираем все файлы в указанной папке
    for file in folder.iterdir():
        # Проверяем, является ли объект файлом
        if file.is_file():
            # Получаем расширение файла (если оно есть), иначе 'Без расширения'
            extension = file.suffix[1:] if file.suffix else 'Без расширения'

            # Формируем путь для папки с соответствующим расширением
            extension_folder = folder / extension

            # Создаём папку для расширения, если она ещё не существует
            extension_folder.mkdir(exist_ok=True)

            # Перемещаем файл в соответствующую папку
            shutil.move(str(file), extension_folder / file.name)

    # Сообщаем, что файлы отсортированы
    print("Файлы отсортированы по типам.")


# Пример: сортировка файлов в указанной папке
sort_files_by_type("C:/Users/User/Downloads")

from moviepy.editor import VideoFileClip


def convert_video_to_gif(video_path, gif_path):
    video = VideoFileClip(video_path)
    video.write_gif(gif_path, fps=60)


convert_video_to_gif("video.mp4",
                     "output.gif")

import requests
from pathlib import Path


def get_random_duck():
    # URL для получения случайной картинки утки
    url = "https://random-d.uk/api/v2/random"
    try:
        # Выполнение GET-запроса для получения данных
        response = requests.get(url)
        response.raise_for_status()  # Проверка на успешный статус запроса
        # Возвращаем URL картинки утки из полученного JSON
        return response.json().get("url")
    except requests.RequestException:
        # В случае ошибки возвращаем None
        return None


def save_duck_image(image_url, folder="ducks"):
    # Определение пути для папки, где будут храниться картинки
    folder_path = Path(folder)
    folder_path.mkdir(parents=True, exist_ok=True)  # Создание папки, если её нет

    try:
        # Запрос для получения картинки по URL
        response = requests.get(image_url)
        response.raise_for_status()  # Проверка на успешный статус запроса
        # Получение имени файла из URL картинки
        image_name = Path(image_url).name
        # Полный путь для сохранения файла
        file_path = folder_path / image_name

        # Открытие файла для записи в бинарном режиме и сохранение содержимого
        with file_path.open('wb') as file:
            file.write(response.content)

        # Выводим сообщение о успешном сохранении
        print(f"Картинка сохранена: {file_path}")
    except requests.RequestException:
        # В случае ошибки при скачивании выводим сообщение
        print("Ошибка при скачивании картинки")


if __name__ == "__main__":
    # Получение случайной картинки утки
    duck_image_url = get_random_duck()
    if duck_image_url:
        # Если URL картинки получен, сохраняем изображение
        save_duck_image(duck_image_url)
    else:
        # Если не удалось получить URL картинки, выводим ошибку
        print("Не удалось получить изображение")

from pathlib import Path


def find_large_files(folder_path, size_threshold_mb):
    # Преобразуем порог размера в байты
    size_threshold_bytes = size_threshold_mb * 1024 * 1024

    # Создаём объект Path для указанной папки
    folder = Path(folder_path)

    # Рекурсивно проходим по всем файлам в папке и подкаталогах
    for file_path in folder.rglob('*'):
        # Проверяем, является ли найденный объект файлом
        if file_path.is_file():
            try:
                # Получаем размер файла в байтах
                file_size = file_path.stat().st_size

                # Если размер файла превышает указанный порог, выводим его путь и размер в МБ
                if file_size > size_threshold_bytes:
                    print(f"{file_path} - {file_size / (1024 ** 2):.2f} MB")
            except FileNotFoundError:
                # Если файл был удалён до обработки, игнорируем ошибку
                pass


# Пример: найти файлы больше 1024 МБ в папке "C:/"
find_large_files("C:/", 1024)

import requests
from PIL import Image
from io import BytesIO


def get_random_image(width: int, height: int):
    """
    Получает случайное изображение с Lorem Picsum API.

    :param width: Ширина изображения.
    :param height: Высота изображения.
    :return: Объект PIL.Image или None в случае ошибки.
    """
    url = f"https://picsum.photos/{width}/{height}"
    try:
        response = requests.get(url)
        response.raise_for_status()  # Проверка на ошибки HTTP
        image = Image.open(BytesIO(response.content))
        return image
    except requests.RequestException as e:
        print(f"Ошибка при запросе изображения: {e}")
        return None


def save_image(image: Image.Image, filename: str):
    """
    Сохраняет изображение в файл.

    :param image: Объект PIL.Image.
    :param filename: Имя файла для сохранения.
    """
    try:
        image.save(filename)
        print(f"Изображение сохранено как {filename}")
    except Exception as e:
        print(f"Ошибка при сохранении изображения: {e}")


if __name__ == "__main__":
    # Указываем размеры изображения
    width = 800
    height = 600

    # Получаем случайное изображение
    random_image = get_random_image(width, height)
    if random_image:
        # Сохраняем изображение в файл
        save_image(random_image, "random_image.jpg")

import os
import hashlib
import logging
from typing import Dict

# Настройка логирования
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler("duplicates.log", encoding="utf-8"),  # Лог записывается в файл
        logging.StreamHandler()  # Лог также выводится в консоль
    ]
)


def get_file_hash(file_path: str, chunk_size: int = 65536) -> str:
    hasher = hashlib.md5()  # Создаем объект хэша MD5
    try:
        # Открываем файл в бинарном режиме для чтения
        with open(file_path, 'rb') as file:
            # Читаем файл частями, чтобы не загружать весь файл в память
            while chunk := file.read(chunk_size):
                hasher.update(chunk)  # Обновляем хэш с помощью очередного блока данных
        return hasher.hexdigest()  # Возвращаем итоговый хэш файла
    except FileNotFoundError:
        logging.error(f"Файл не найден: {file_path}")  # Логируем ошибку, если файл отсутствует
        raise
    except PermissionError:
        logging.error(f"Нет доступа к файлу: {file_path}")  # Логируем ошибку, если нет прав доступа
        raise


def find_duplicates(folder_path: str) -> None:
    # Проверяем, существует ли указанная директория
    if not os.path.exists(folder_path):
        logging.error(f"Указанная директория не существует: {folder_path}")
        return

    # Словарь для хранения хэшей файлов и их путей
    files_hash: Dict[str, str] = {}
    # Проходимся по всем папкам, подкаталогам и файлам в директории
    for root, dirs, files in os.walk(folder_path):
        for file in files:  # Обрабатываем каждый файл в текущей директории
            file_path = os.path.join(root, file)  # Формируем полный путь к файлу
            try:
                # Вычисляем хэш текущего файла
                file_hash = get_file_hash(file_path)
                if file_hash in files_hash:
                    # Если хэш уже есть в словаре, то найден дубликат
                    logging.info(f"Дубликат найден: {file_path} и {files_hash[file_hash]}")
                else:
                    # Если хэша нет в словаре, добавляем файл в словарь
                    files_hash[file_hash] = file_path
            except Exception as e:
                # Логируем любые ошибки, возникшие при обработке файла
                logging.warning(f"Не удалось обработать файл {file_path}: {e}")


if __name__ == "__main__":
    # Пример: поиск дубликатов в указанной директории
    target_folder = r"C:\Users\User\Documents"
    find_duplicates(target_folder)

from moviepy.editor import VideoFileClip, CompositeVideoClip, ImageClip
from PIL import Image, ImageDraw, ImageFont
import numpy as np


def add_watermark(input_video, output_video, watermark_text, font_size=24, position=("right", "bottom"), opacity=128):
    # Загружаем видео
    video = VideoFileClip(input_video)

    # Создаём изображение с текстом водяного знака
    font_path = "arial.ttf"  # Указываем путь к файлу шрифта
    font = ImageFont.truetype(font_path, font_size)

    # Получаем размеры текста
    text_bbox = font.getbbox(watermark_text)
    text_width, text_height = text_bbox[2], text_bbox[3]

    # Создаём прозрачное изображение для водяного знака
    watermark_image = Image.new("RGBA", (text_width, text_height), (0, 0, 0, 0))
    draw = ImageDraw.Draw(watermark_image)
    draw.text((0, 0), watermark_text, font=font, fill=(255, 255, 255, opacity))

    # Преобразуем Pillow-изображение в NumPy-массив
    watermark_array = np.array(watermark_image)

    # Конвертируем NumPy-массив в ImageClip
    watermark_clip = ImageClip(watermark_array).set_duration(video.duration)

    # Определяем позицию водяного знака
    if position == ("right", "bottom"):
        position = (video.size[0] - text_width - 10, video.size[1] - text_height - 10)
    elif position == ("left", "top"):
        position = (10, 10)
    elif position == ("right", "top"):
        position = (video.size[0] - text_width - 10, 10)
    elif position == ("left", "bottom"):
        position = (10, video.size[1] - text_height - 10)

    watermark_clip = watermark_clip.set_position(position)

    # Создаем итоговое видео
    final_video = CompositeVideoClip([video, watermark_clip])
    final_video.write_videofile(output_video, codec="libx264", audio_codec="aac")


# Пример использования
add_watermark(
    input_video="input.mp4",
    output_video="output_with_watermark.mp4",
    watermark_text="My Watermark",
    font_size=36,
    position=("right", "bottom"),
    opacity=200
)

from PIL import Image, ImageDraw, ImageFont


def create_image_with_text(text, output_path="output.png", text_size=36, position="center"):
    # Создаём новое изображение размером 800x400, цвет фона - тёмно-синий
    img = Image.new("RGB", (800, 400), color=(73, 109, 137))
    # Инициализируем объект для рисования
    draw = ImageDraw.Draw(img)

    # Загружаем шрифт Arial с указанным размером текста
    font = ImageFont.truetype("arial.ttf", size=text_size)

    # Вычисляем размер текста с помощью textbbox (границы текста в формате (x_min, y_min, x_max, y_max))
    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]  # Ширина текста
    text_height = text_bbox[3] - text_bbox[1]  # Высота текста

    # Устанавливаем координаты текста в зависимости от выбранного положения
    if position == "center":  # Центр изображения
        text_x = (img.width - text_width) // 2
        text_y = (img.height - text_height) // 2
    elif position == "top-left":  # Верхний левый угол
        text_x, text_y = 10, 10
    elif position == "top-right":  # Верхний правый угол
        text_x = img.width - text_width - 10
        text_y = 10
    elif position == "bottom-left":  # Нижний левый угол
        text_x = 10
        text_y = img.height - text_height - 10
    elif position == "bottom-right":  # Нижний правый угол
        text_x = img.width - text_width - 10
        text_y = img.height - text_height - 10
    else:
        # Если указано некорректное положение, выбрасываем исключение
        raise ValueError(
            "Недопустимое значение для position. Используйте: center, top-left, top-right, bottom-left, bottom-right."
        )

    # Добавляем текст на изображение по рассчитанным координатам
    draw.text((text_x, text_y), text, fill="white", font=font)
    # Сохраняем изображение в файл
    img.save(output_path)
    # Выводим сообщение о сохранении файла
    print(f"Изображение сохранено как {output_path}")


# Запрашиваем у пользователя текст для изображения
text = input("Введите текст для изображения: ")
# Запрашиваем у пользователя размер текста
text_size = int(input("Введите размер текста: "))
# Предлагаем выбрать расположение текста
print(
    "Выберите расположение текста: center, top-left, top-right, bottom-left, bottom-right"
)
# Получаем выбор пользователя
position = input("Введите расположение текста: ").strip()
# Вызываем функцию с указанными параметрами
create_image_with_text(text, text_size=text_size, position=position)

import random
import time
from colorama import init, Fore

init(autoreset=True)  # Инициализация colorama


def draw_tree(height=10):
    try:
        while True:
            print("\033c", end="")  # Очистка консоли
            print("Новогодняя ёлка\n")
            for i in range(1, height + 1):
                level = " " * (height - i) + "*" * (2 * i - 1)
                decorated_level = "".join(
                    random.choice([
                        Fore.GREEN + "*",  # Зелёная звезда
                        Fore.RED + "o",    # Красный шарик
                        Fore.YELLOW + "x"  # Жёлтая гирлянда
                    ]) if char == "*" else char for char in level)
                print(decorated_level)
            print(" " * (height - 1) + Fore.MAGENTA + "|||")  # Ствол
            time.sleep(0.5)  # Пауза для анимации
    except KeyboardInterrupt:
        print("\nАнимация остановлена. С наступающим Новым годом!")


if __name__ == "__main__":
    draw_tree()

from moviepy.editor import VideoFileClip
from moviepy.video.fx import all as vfx

# Загрузка видео
clip = VideoFileClip("input_video.mp4")

# Применение черно-белого фильтра
clip = vfx.blackwhite(clip)

# Сохранение результата
clip.write_videofile("black_and_white_video.mp4")

import qrcode

# Данные для подключения к Wi-Fi
ssid = 'Your_WiFi_SSID'  # Имя сети
password = 'Your_WiFi_Password'  # Пароль

# Формирование строки для подключения
wifi_string = f"WIFI:T:WPA;S:{ssid};P:{password};;"

# Генерация QR-кода
qr = qrcode.QRCode(
    version=1,
    error_correction=qrcode.constants.ERROR_CORRECT_L,
    box_size=10,
    border=4,
)
qr.add_data(wifi_string)
qr.make(fit=True)

# Создание изображения QR-кода
img = qr.make_image(fill='black', back_color='white')

# Сохранение изображения
img.save("wifi_qr.png")

from pathlib import Path
from PyPDF2 import PdfMerger


def merge_pdfs_in_directory(directory_path, output_path):
    # Создаём объект PdfMerger
    merger = PdfMerger()

    # Перебираем все PDF файлы в директории
    for file_path in Path(directory_path).rglob('*.pdf'):
        merger.append(file_path)

    # Сохраняем объединённый PDF
    merger.write(output_path)
    merger.close()


directory_path = r'C:\путь\к\директории'  # Путь к директории с PDF файлами
output_path = r'C:\путь\к\выходному_файлу\merged_output.pdf'  # Путь для итогового файла

merge_pdfs_in_directory(directory_path, output_path)

import requests
from PIL import Image, ImageDraw, ImageFont
import random


# Получаем случайный шаблон мемов
def get_random_meme_template():
    url = "https://api.imgflip.com/get_memes"
    response = requests.get(url).json()
    memes = response['data']['memes']
    meme = random.choice(memes)
    return meme['url']


# Создаём мем
def create_meme(image_url, text):
    img = Image.open(requests.get(image_url, stream=True).raw)
    draw = ImageDraw.Draw(img)

    # Задаём параметры шрифта
    font = ImageFont.truetype("arial.ttf", 40)

    # Получаем размеры текста
    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]

    # Смещаем текст выше от нижнего края
    padding = 50  # Отступ от нижнего края
    position = ((img.width - text_width) / 2, img.height - text_height - padding)

    # Рисуем текст на изображении
    draw.text(position, text, font=font, fill="white", stroke_fill="black", stroke_width=2)
    img.save("meme.png")
    print("Мем создан и сохранен как meme.png.")


meme_url = get_random_meme_template()
text = input("Введите текст для мема: ")
create_meme(meme_url, text)

import movis as mv

# Создаём композицию с размером 1920x1080 пикселей и продолжительностью 8 секунд
scene = mv.layer.Composition(size=(1920, 1080), duration=8.0)

# Добавляем первый видео слой из файла 'video1.mp4' в композицию, начало с 0 секунды
video1 = scene.add_layer(mv.layer.Video('video1.mp4'), offset=0.0)

# Добавление второй видео слой из файла 'video2.mp4' в композицию, начало с 4 секунд
video2 = scene.add_layer(mv.layer.Video('video2.mp4'), offset=4.0)

# Сохраняем итоговое видео
scene.write_video('multi_video_layer.mp4')

import movis as mv

# Создаём композицию размером 1920x1080 пикселей и длительностью 5 секунд
scene = mv.layer.Composition(size=(1920, 1080), duration=5.0)

# Добавляем фоновый прямоугольник красного цвета
scene.add_layer(mv.layer.Rectangle(scene.size, color='#fb4562'))

# Добавляем текстовый слой с анимацией появления
text_layer = scene.add_layer(
    mv.layer.Text('Hello World!', font_size=100, font_family='Arial', color='#ffffff'),
    offset=1.0,  # Текст появится через 1 секунду
    position=(960, 540),  # Центр композиции
    opacity=0.0  # Начальная прозрачность
)

# Анимация плавного появления текста
text_layer.opacity.enable_motion().extend([0.0, 1.0], [0.0, 1.0])

# Сохраняем видео
scene.write_video('output.mp4')

import pandas as pd

# Чтение HTML-файла с таблицами
html_file = 'example.html'  # Указываем путь к HTML-файлу с таблицами
# Читаем все таблицы из HTML-файла, возвращается список DataFrame
tables = pd.read_html(html_file)

# Проверяем, что таблицы загружены
if tables:  # Условие проверяет, есть ли таблицы в списке
    # Открываем Excel-файл для записи с использованием ExcelWriter
    with pd.ExcelWriter('output.xlsx', engine='openpyxl') as writer:
        # Перебираем таблицы и записываем каждую на отдельный лист
        for i, table in enumerate(tables):
            # Сохраняем текущую таблицу в Excel, создавая новый лист для каждой
            table.to_excel(writer, sheet_name=f'Table_{i+1}', index=False)
        # Сообщаем, что все таблицы успешно сохранены
        print("Все таблицы успешно сохранены в Excel.")
else:
    # Выводим сообщение, если таблиц в HTML-файле не обнаружено
    print("Таблицы не найдены в HTML-файле.")

from PIL import Image


def image_to_ascii(image_path, output_path, width=100):
    # Открываем изображение по указанному пути
    img = Image.open(image_path)
    # Конвертируем изображение в градации серого ('L' - режим grayscale)
    img = img.convert('L')
    # Вычисляем соотношение сторон изображения
    aspect_ratio = img.height / img.width
    # Определяем новую высоту, сохраняя соотношение сторон
    new_height = int(aspect_ratio * width * 0.55)
    # Изменяем размер изображения согласно новым параметрам
    img = img.resize((width, new_height))

    # Получаем пиксельные данные изображения
    pixels = img.getdata()
    # Определяем набор символов для ASCII
    chars = ["@", "#", "S", "%", "?", "*", "+", ";", ":", ",", "."]
    # Преобразуем пиксели в ASCII символы
    ascii_str = "".join([chars[pixel // 25] for pixel in pixels])
    # Получаем длину строки ASCII
    ascii_str_len = len(ascii_str)
    # Формируем строку ASCII изображения с нужной шириной
    ascii_img = "\n".join([ascii_str[index: index + width] for index in range(0, ascii_str_len, width)])

    # Открываем файл в режиме для записи
    with open(output_path, "w") as f:
        # Записываем ASCII изображение в файл
        f.write(ascii_img)


image_to_ascii('image.png', 'output.txt')

from bs4 import BeautifulSoup


def extract_tables_from_file(file_path):
    # Открываем файл по указанному пути в режиме чтения с кодировкой UTF-8
    with open(file_path, 'r', encoding='utf-8') as file:
        # Читаем содержимое файла и сохраняем его в переменной html
        html = file.read()
        
    # Создаем объект BeautifulSoup для парсинга HTML-кода
    soup = BeautifulSoup(html, 'html.parser')
    # Инициализируем пустой список для хранения извлеченных таблиц
    tables = []
    # Находим все элементы <table> в HTML-документе
    for table in soup.find_all('table'):
        # Инициализируем пустой список для хранения строк текущей таблицы
        rows = []
        # Находим все строки <tr> в текущей таблице
        for row in table.find_all('tr'):
            # Извлекаем текст из всех ячеек <td> и <th>, убирая лишние пробелы
            cells = [cell.get_text(strip=True) for cell in row.find_all(['td', 'th'])]
            # Добавляем список ячеек в список строк
            rows.append(cells)
        # Добавляем список строк в общий список таблиц
        tables.append(rows)
    # Возвращаем список всех извлеченных таблиц
    return tables


# Вызываем функцию и выводим результат для файла 'example.html'
print(extract_tables_from_file('example.html'))

from pathlib import Path
from pdf2docx import Converter

# Определяем путь к директории с PDF файлами
pdf_dir = Path('pdf_files')
# Определяем путь к директории, куда будут сохранены DOCX файлы
docx_dir = Path('docx_files')

# Проверяем, существует ли директория для DOCX файлов
if not docx_dir.exists():
    # Если директория не существует, создаём её
    docx_dir.mkdir()

# Проходимся по всем PDF файлам в директории pdf_files
for pdf_file in pdf_dir.glob('*.pdf'):  # Используем метод glob для поиска всех файлов с расширением .pdf
    # Создаём путь для нового DOCX файла, заменяя расширение на .docx
    docx_file = docx_dir / pdf_file.with_suffix('.docx').name
    # Создаем экземпляр Converter для текущего PDF файла
    cv = Converter(pdf_file)
    # Конвертируем PDF файл в DOCX и сохраняем его по указанному пути
    cv.convert(docx_file)
    # Закрываем экземпляр Converter после завершения конвертации
    cv.close()

from fpdf import FPDF

# Создаём PDF-документ
pdf = FPDF()
pdf.add_page()

# Устанавливаем шрифт
pdf.set_font("helvetica", size=12)

# Добавляем текст
pdf.cell(200, 10, text="Hello, World!", align='C')

# Сохраняем PDF
pdf.output("hello_world.pdf")