Привет! На связи Иван, и сегодня поговорим о том, как научить свои скрипты понимать команды из терминала. Представь: ты написал крутую утилиту, и теперь хочешь запускать её с разными параметрами, а не каждый раз менять код или жонглировать input(). На помощь приходит модуль argparse — встроенный в Python инструмент для парсинга аргументов командной строки.

Никакой магии, только понятный и мощный API. Давайте разберёмся, как он работает на практике.

Начнем с мини-примера:

import argparse

parser = argparse.ArgumentParser(description='Simple greeting script')
parser.add_argument('--name', type=str, help='Name of the person')
args = parser.parse_args()

print(f"Hello, {args.name}!")

Попробуй теперь вызвать скрипт из консоли так:

python script.py --name Alice

И получишь: Hello, Alice!

Что здесь происходит?

- ArgumentParser запускает “приёмную кампанию” для аргументов.
- add_argument() указывает, что мы ждём аргумент --name, и какого он типа.
- parse_args() превращает пользовательский ввод в объект с атрибутами.

Теперь усилим пример. Добавим обязательный аргумент и флаг:

parser.add_argument('filename', type=str, help='Path to the input file')
parser.add_argument('--verbose', action='store_true', help='Enable verbose mode')

Команды:

python script.py data.txt --verbose

Здесь filename — позиционный аргумент (обязателен), а --verbose — флаг (включается, если указан).

Тебе не нужно писать код для проверки: есть ли аргументы, правильно ли указаны — за это отвечает argparse. Даже help-меню (да, оно генерируется само!) можно получить так:

python script.py --help

Вы получите подробную справку автоматически. Удобно? Очень.

👀 А теперь пример посложнее — калькулятор с операцией и числами:

parser = argparse.ArgumentParser(description='Simple calculator')
parser.add_argument('operation', choices=['add', 'sub'], help='Operation to perform')
parser.add_argument('x', type=int, help='First number')
parser.add_argument('y', type=int, help='Second number')
args = parser.parse_args()

if args.operation == 'add':
    result = args.x + args.y
else:
    result = args.x - args.y

print(f"Result: {result}")

Вызов:

python calc.py add 3 7
# Выведет: Result: 10

А если указать что-то кроме add или sub — argparse не даст запустить скрипт.

Вот за что я люблю этот модуль — минимум кода, максимум пользы. У него есть и более продвинутые возможности: группы аргументов, парсинг вложенных команд, типы вроде float или datetime. Для больших CLI-добавлений можно использовать argparse в связке с модулями subparsers или даже перейти на click, но это уже другая история.

Если ты хочешь превратить свой скрипт в полноценный инструмент командной строки — начинай с argparse. Он встроен, прост и отлично масштабируется.

До встречи в следующем посте!

Как управлять состоянием приложения с помощью Python-классов

Привет, друзья! Сегодня поговорим о том, как удобно и понятно управлять состоянием приложения с помощью обычных Python-классов. Ведь даже в самом простом проекте нам часто нужно отслеживать, где находится пользователь, какие данные он ввёл, открыт ли файл, активна ли сессия и много чего ещё. Давайте разберёмся, как сделать это грамотно.

Когда мы говорим «состояние приложения», мы подразумеваем набор параметров, описывающих его текущую "жизнь". Если подходить к этому хаотично — создавая глобальные переменные или передавая «состояние» вручную в каждую функцию, — приложение быстро превратится в кошмар для сопровождения.

Вот тут и приходят на помощь классы.

Посмотрим на простой пример. Допустим, мы разрабатываем текстовый редактор:

class TextEditorState:
    def __init__(self):
        self.filename = None
        self.content = ""
        self.modified = False

    def load_file(self, filename):
        with open(filename, "r", encoding="utf-8") as f:
            self.content = f.read()
        self.filename = filename
        self.modified = False

    def update_content(self, new_content):
        self.content = new_content
        self.modified = True

    def save(self):
        if self.filename:
            with open(self.filename, "w", encoding="utf-8") as f:
                f.write(self.content)
            self.modified = False

Теперь у нас есть полноценный контейнер состояния редактора. Всё, что может происходить: загрузка файла, изменения, сохранение — оформлено методами класса. И главное, состояние (content, filename, modified) всегда у нас под контролем и в одном месте.

Но зачем вообще класс, если можно просто передавать словарь?

Во-первых, классы позволяют инкапсулировать поведение: вы определяете не только данные, но и то, как с ними можно работать. Во-вторых — читаемость, масштабируемость, интеграция с типизацией. Это особенно ценно, когда приложение растёт.

Давайте усложним задачу. Создадим что-нибудь вроде простого игрового состояния:

class GameState:
    def __init__(self):
        self.level = 1
        self.score = 0
        self.inventory = []

    def next_level(self):
        self.level += 1

    def add_score(self, points):
        self.score += points

    def add_item(self, item):
        self.inventory.append(item)

    def reset(self):
        self.level = 1
        self.score = 0
        self.inventory.clear()

Теперь GameState знает, как себя "вести", когда игра запускается, когда игрок переходит на следующий уровень или завершает сессию. Такой подход прекрасно масштабируется: можно добавить сохранение/загрузку в JSON, можно сделать отдельные состояния для игрока, врагов, меню — и всё это будет изолировано и логично.

Небольшой бонус — использование dataclass:

from dataclasses import dataclass, field

@dataclass
class SessionState:
    user_id: int
    is_authenticated: bool = False
    preferences: dict = field(default_factory=dict)

Идеально для хранения данных без лишнего кода. Если вам не нужно особое поведение, а просто нужно "держать" состояние — отличный и лаконичный способ.

Итак, если вы только начинаете с Python и ваш проект постепенно обрастает логикой и данными — начинайте формировать привычку описывать состояниe через классы. Это помогает избежать хаоса, делает код чище, тесты — проще, а вас — спокойнее.

До встречи!
– Иван 👨‍💻

Создание простой блога с использованием Markdown и Flask

Привет! Сегодня мы сделаем кое-что особенно полезное: создадим простой блог с помощью Flask — лёгкого микрофреймворка — и Markdown, удобного формата для написания текста с элементами разметки. Это отличный проект для начинающих: быстро, понятно и наглядно.

Почему Markdown? Потому что он интуитивно понятен. Вы просто пишете текст с легкой разметкой (заголовки, списки, ссылки), а потом через Python превращаете это в полноценную HTML-страницу. Удобно и красиво!

Начнем с простого примера структуры папок:

simple_blog/
├── app.py
├── posts/
│   ├── first_post.md
│   └── second_post.md
├── templates/
│   ├── base.html
│   └── post.html

Установим необходимые модули:

pip install flask markdown

Теперь — немного кода. Файл app.py:

import os
from flask import Flask, render_template, abort
import markdown

app = Flask(__name__)
POSTS_DIR = 'posts'

def get_post_content(filename):
    path = os.path.join(POSTS_DIR, filename)
    if not os.path.exists(path):
        return None
    with open(path, 'r', encoding='utf-8') as f:
        return markdown.markdown(f.read())

@app.route('/')
def index():
    posts = [f[:-3] for f in os.listdir(POSTS_DIR) if f.endswith('.md')]
    return render_template('base.html', posts=posts)

@app.route('/post/<name>')
def post(name):
    html_content = get_post_content(f"{name}.md")
    if html_content is None:
        abort(404)
    return render_template('post.html', content=html_content, title=name)

Темплейт base.html — список постов:

<!doctype html>
<html>
<head><title>Simple Blog</title></head>
<body>
    <h1>My Simple Blog</h1>
    <ul>
        {% for name in posts %}
            <li><a href="{{ url_for('post', name=name) }}">{{ name }}</a></li>
        {% endfor %}
    </ul>
</body>
</html>

Темплейт post.html — отображение Markdown:

<!doctype html>
<html>
<head><title>{{ title }}</title></head>
<body>
    <a href="{{ url_for('index') }}">← Back to blog</a>
    <hr>
    {{ content | safe }}
</body>
</html>

Пример Markdown-файла posts/first_post.md:

# Привет, мир!

Это мой первый пост в блоге на **Flask** и _Markdown_.

- Я пишу текст в Markdown
- Flask превращает его в HTML
- Всё просто!

На этом и всё! Вы получаете минималистичный блог, в который удобно добавлять посты, просто сохраняя их в виде .md-файлов. Нет базы данных, нет тяжелых CMS — только Flask, Markdown и немного магии Python.

Удачи в кодинге!
— Иван.

Обработка файлов CSV с использованием модуля csv

📁 CSV-файлы и модуль csv: удобный вход в мир данных на Python
Привет! С вами Иван — и сегодня мы поговорим о том, как Python помогает обращаться с CSV-файлами с лёгкостью и грацией библиотекаря, разбирающего карточный каталог.

CSV — это табличные данные в виде обычного текста, разделённого запятыми (Comma-Separated Values). Это один из самых популярных и доступных форматов обмена данными между сервисами, программами и людьми. Работаешь с Excel? Экспортируешь из Google Sheets? Загружаешь выгрузку из CRM? Почти наверняка — это CSV.

В Python для работы с такими файлами есть мощный встроенный модуль — csv. Он не требует отдельной установки и готов к работе сразу после установки Python. Давайте взглянем, как с ним подружиться.

📦 Чтение CSV-файлов

Начнём с базы. Предположим, у нас есть файл data.csv:

name,age,city
Alice,30,New York
Bob,25,London
Charlie,35,Berlin

Прочитаем его, используя csv.reader:

import csv

with open('data.csv', newline='') as csvfile:
    reader = csv.reader(csvfile)
    for row in reader:
        print(row)

Вывод:

['name', 'age', 'city']
['Alice', '30', 'New York']
['Bob', '25', 'London']
['Charlie', '35', 'Berlin']

Каждая строка CSV превращается в список строк. Просто и удобно!

Но чаще хочется работать с данными по ключам, а не по индексам. На помощь приходит csv.DictReader:

import csv

with open('data.csv', newline='') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        print(row['name'], 'from', row['city'])

Вывод:

Alice from New York
Bob from London
Charlie from Berlin

Такой способ уже больше похож на работу с JSON или базой данных.

📝 Запись CSV-файлов

Допустим, теперь ты хочешь сохранить обработанные данные. Для этого используется csv.writer:

import csv

data = [
    ['product', 'price'],
    ['laptop', '1200'],
    ['phone', '800'],
    ['tablet', '500']
]

with open('products.csv', 'w', newline='') as csvfile:
    writer = csv.writer(csvfile)
    writer.writerows(data)

Или, с заголовками и словарями:

import csv

data = [
    {'product': 'laptop', 'price': 1200},
    {'product': 'phone', 'price': 800},
    {'product': 'tablet', 'price': 500},
]

with open('products_dict.csv', 'w', newline='') as csvfile:
    fieldnames = ['product', 'price']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

    writer.writeheader()
    for item in data:
        writer.writerow(item)

Оба способа сохранят таблицу в читаемом виде, которую можно открыть даже в Excel.

🔧 Немного тонкостей

- Модуль csv справляется не только с запятыми — можно задать любой разделитель через параметр delimiter.
- Не забудь про newline='' при открытии файла — это нужно для правильной работы на Windows.
- Если ты хочешь обрабатывать большой файл построчно — модуль csv делает это достаточно эффективно, не загружая весь файл в память.

🎁 Вывод

csv — один из тех модулей Python, про который можно забыть… а потом снова открыть, порадоваться, и не думать о ручном разборе текста. Он удобен, предсказуем и отличный старт для тех, кто только начинает работать с данными.

Дальше будет интереснее — впереди pandas, но csv — отличный первый шаг.

До связи, Иван.

Работа с файловой системой: поиск и управление файлами с help модуля os

Привет! С вами Иван, и сегодня поговорим о работе с файловой системой на Python. Если вы думаете, что модуль os — это скучный рудимент из древних Python-эпох, то вы сильно заблуждаетесь. Этот модуль — настоящая швейцарская армия программиста: он позволяет шастать по директориям, искать, удалять, переименовывать и создавать файлы, словно вы — повелитель вашей файловой империи. Давайте нырнем в эту тему вместе.

Начнем с главного — исследования текущей директории:

import os

# Получаем текущую рабочую директорию
current_dir = os.getcwd()
print(f"Current working directory: {current_dir}")

Теперь пробежимся по файлам и папкам:

for item in os.listdir(current_dir):
    item_path = os.path.join(current_dir, item)
    if os.path.isfile(item_path):
        print(f"File: {item}")
    elif os.path.isdir(item_path):
        print(f"Directory: {item}")

Элементарно, Ватсон? А вот теперь интереснее.

Допустим, вам нужно найти все файлы с расширением .txt в какой-нибудь глубокой-длинной папке. Для этого отлично подходит os.walk:

search_root = "/path/to/search"

for root, dirs, files in os.walk(search_root):
    for file in files:
        if file.endswith(".txt"):
            print(f"Found: {os.path.join(root, file)}")

os.walk рекурсивно обходит все директории, будто у него бесконечные силы. Отличный инструмент для файловой разведки.

А как насчет создания и удаления директорий?

new_dir = os.path.join(current_dir, "new_folder")

if not os.path.exists(new_dir):
    os.mkdir(new_dir)
    print(f"Created directory: {new_dir}")
else:
    print(f"Directory already exists: {new_dir}")

# Удаление
os.rmdir(new_dir)
print(f"Deleted directory: {new_dir}")

Важно: os.rmdir удалит папку только если она пустая. Если внутри что-то есть — получите ошибку. Для сложных случаев уже нужен модуль shutil, но об этом — в другой раз.

И на десерт — переименование файла:

old_name = os.path.join(current_dir, "old_file.txt")
new_name = os.path.join(current_dir, "new_file.txt")

if os.path.exists(old_name):
    os.rename(old_name, new_name)
    print(f"Renamed to: {new_name}")

Всё просто: немного условий, и вы уже управляете файлами как администратор чужого сервера.

Да, модуль os выглядит скромно, но за его простым интерфейсом скрываются мощные возможности. Умея пользоваться im, вы сможете автоматизировать многое: от сортировки загрузок до сканирования большого дерева проектов — всё в пределах нескольких строк.

Пишите Python-скрипты, которые делают рутину за вас. И пусть файловая система подчинится вам!

Как использовать Python для периодических задач с помощью модуля sched

Привет! С вами Иван — и сегодня я расскажу, как с помощью Python и стандартного модуля sched решать задачи, которые должны выполняться периодически. Даже если вы только начинаете изучать язык, этот инструмент может значительно облегчить вашу жизнь.

Вы наверняка сталкивались с ситуациями, когда нужно что-то делать через определённые интервалы времени: например, проверять обновления на сайте, делать резервные копии или отправлять уведомления. Обычно на помощь приходит time.sleep или даже многопоточность, но в Python уже есть гораздо более тонкое и приятное средство — модуль sched.

## В чём суть sched?

Модуль sched реализует планировщик событий. Вы создаёте объект планировщика, добавляете в него задачи, указываете время запуска — и планировщик сам их аккуратно "отпускает в бой".

Вот базовый пример:

import sched
import time

def print_message(name):
    print(f"Hello, {name}! The time is {time.ctime()}")

scheduler = sched.scheduler(time.time, time.sleep)
scheduler.enter(3, 1, print_message, argument=("Ivan",))
scheduler.enter(6, 1, print_message, argument=("Pythonista",))
scheduler.run()

Этот код выведет приветствие сначала через 3 секунды, затем через 6 секунд от запуска. Всё просто: enter — добавить задачу через указанное время, run — начать выполнение.

## Как сделать периодическую задачу?

Секрет тут в самой функции-обработчике: она добавляет себя обратно в планировщик. Пример создания "бесконечного повторения" раз в 5 секунд:

import sched
import time

def periodic_task(scheduler, interval):
    print(f"Periodic task runs at {time.ctime()}")
    scheduler.enter(interval, 1, periodic_task, (scheduler, interval))

scheduler = sched.scheduler(time.time, time.sleep)
scheduler.enter(0, 1, periodic_task, (scheduler, 5))
scheduler.run()

Функция periodic_task при каждом вызове снова добавляет себя в расписание через 5 секунд — и так до бесконечности (или пока не остановите программу).

## Особенности и когда использовать

sched отлично подходит для простых задач планирования в одном потоке. Если у вас десятки тысяч событий или критична высокая точность — лучше смотрите в сторону более продвинутых библиотек (например, APScheduler или Celery). Но для домашних проектов и скриптов эта маленькая "швейцарская армия" планирования будет как нельзя кстати.

Подытожим: модуль sched — это минималистичный, но удобный планировщик для несложных задач во времени. А если хочется почувствовать себя дирижёром событий — стоит попробовать!

На связи был Иван. Экспериментируйте с Python — он полон приятных сюрпризов!

Создание простых web-серверов с помощью HTTPServer

Привет! С вами Иван, и сегодня мы поговорим о создании простых web-серверов на Python с модулем http.server. Это настоящий магический ящик для новичка: буквально в пару строк кода Python превращается в миниатюрный web-сервер.

## Первый шаг: поднимаем сервер за минуту

Если у вас установлен Python 3 (а иначе зачем вы тут?), достаточно одной команды в терминале:

python -m http.server 8000

Теперь любой браузер может открыть http://localhost:8000, чтобы увидеть содержимое вашей текущей папки. Вот так просто вы уже раздаёте файлы через HTTP!

## Немного кода — пишем свой сервер

Но как же написать сервер вручную и добавить, например, свою страничку? Для этого используем класс HTTPServer и обработчик запросов BaseHTTPRequestHandler.

from http.server import HTTPServer, BaseHTTPRequestHandler

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(b"<h1>Hello, Python Web!</h1>")

server = HTTPServer(('localhost', 8080), MyHandler)
print("Starting server at http://localhost:8080")
server.serve_forever()

Теперь, заходя на http://localhost:8080, вы увидите свою HTML-страничку с приветствием.

## Немного магии: отдаём разные страницы

Хотите разные ответы по разным адресам? Сделайте так:

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/':
            message = "<h1>Home page</h1>"
        elif self.path == '/about':
            message = "<h1>About page</h1>"
        else:
            self.send_response(404)
            self.end_headers()
            self.wfile.write(b"Not found")
            return
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(message.encode())

Теперь странички / и /about будут разными, а всё остальное выдаёт 404.

## Зачем всё это нужно?

http.server — идеальный инструмент для обучения, тестов или быстрой раздачи файлов. Если нужна "взрослая" разработка — смотрите в сторону Flask или FastAPI. Но иногда и простой сервер — всё, что нужно!

На этом всё! Пусть код будет с вами, а сервер — быстрым и надёжным.

Изучение структуры проектов: создание setup.py для пакетов

Изучение структуры проектов: создание setup.py для пакетов

Привет! Я Иван, и сегодня мы разгадаем классическую загадку каждого, кто хочет поделиться своим Python-кодом с миром: зачем нужен файл setup.py и как его создать? Если вы мечтаете сделать свой модуль частью Pypi, или хотя бы перекатывать свои библиотеки между проектами, эта информация станет для вас ключевой.

## Зачем нужен setup.py?

setup.py — это сердце любого Python-пакета. Именно этот файл позволяет устанавливать ваш проект через pip, автоматически подключать зависимости и "рассказывает" системе, как обращаться с вашим кодом. Без него — никакой штатной установки, простого экспорта и удобного распространения.

## Основная структура

Минимальный setup.py выглядит буквально как заклинание:

from setuptools import setup

setup(
    name="hello_world_package",
    version="0.1",
    packages=["hello_world"],  # имя директории с модулем
)

Здесь setuptools — это библиотека, без которой современное создание пакетов не обходится. А параметры — прямое описание вашего пакета.

## Добавим подробностей

Давайте сделаем setup.py чуть более осмысленным:

from setuptools import setup, find_packages

setup(
    name="my_cool_lib",
    version="1.0.0",
    description="A cool library that says hello",
    author="Ivan",
    author_email="ivan@example.com",
    packages=find_packages(),
    install_requires=[
        "requests>=2.0"
    ],
    entry_points={
        "console_scripts": [
            "say-hello = my_cool_lib.hello:main"
        ]
    }
)

Поясню ключевые моменты:
- install_requires — список зависимостей, которые будут автоматически установлены при инсталляции вашего пакета.
- entry_points позволяет создавать консольные команды. После установки вашего пакета пользователь сможет запустить say-hello прямо из терминала!
- find_packages() сам найдет все подпакеты в вашей директории.

## Минимальный набор файлов

Типичная структура простого пакета такова:

my_cool_lib/
    __init__.py
    hello.py
setup.py
README.md

Помещайте исходный код в отдельную директорию, не на одном уровне с setup.py — так вы избежите многих проблем в будущем.

## Итоги

Создание setup.py — это шаг к профессиональной разработке. Даже если вы пока не планируете выкладывать свой код в открытый доступ, формирование пакета с setup.py улучшит структуру ваших проектов.

Я, Иван, советую не откладывать знакомство с этим файлом: структурные привычки закладываются с первых строчек кода!

Как запускать и управлять процессами с помощью subprocess

Привет! На связи Иван, и сегодня мы поговорим о том, как запускать и управлять внешними процессами в Python с помощью модуля subprocess. Казалось бы, зачем это нужно? А вот представьте, что вашему скрипту нужно запустить внешний инструмент, обработать его вывод, или даже — автоматизировать какую-то рутинку в системе. Тут и приходит на помощь этот мощный модуль!

### Быстрый старт: subprocess.run

Один из самых простых способов что-то запустить — воспользоваться функцией subprocess.run. Например, откроем и узнаем содержимое текущей папки:

import subprocess

result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)

Здесь мы передаем список аргументов команды (имя команды и параметры) и получаем результат её выполнения. С выходом Python 3.5 использовать capture_output стало невероятно удобно: весь вывод команды оказывается у вас под рукой.

### Повышаем сложность: захватываем ошибки

Иногда команды ведут себя неидеально — возвращают ошибки. Посмотрим, как их поймать:

process = subprocess.run(['ls', '/nonexistent_folder'], capture_output=True, text=True)
if process.returncode != 0:
    print(f"Error: {process.stderr}")

Благодаря returncode и stderr, можно легко понять, что пошло не так.

### Взаимодействие с процессом: subprocess.Popen

Когда нужен больший контроль — например, нужно читать вывод по мере поступления или отправлять данные на вход процесса — пригодится subprocess.Popen. Пример: читаем вывод строчка за строчкой в реальном времени.

with subprocess.Popen(['ping', '-c', '3', 'google.com'], stdout=subprocess.PIPE, text=True) as proc:
    for line in proc.stdout:
        print(line.strip())

Здесь мы "слушаем" вывод команды ping, не дожидаясь полного завершения.

### Передаем данные процессу

Если нужно взаимодействовать через stdin — элементарно! Например, отправим текст на вход команде grep:

process = subprocess.run(['grep', 'Python'], input='Python is awesome!\nHello World!', text=True, capture_output=True)
print(process.stdout)

Вы увидите только строки, где встречается "Python".

### Итог

subprocess — настоящий швейцарский нож для управления внешними процессами на Python. Им можно и просто запускать скрипты, и строить вот такие мини-системы автоматизации с интерактивным взаимодействием.

До встречи — буду рад поделиться и другими трюками языка Python!

Использование цвета в терминале с модулем colorama

Привет! На связи Иван, и сегодня я расскажу, как добавить немного цветов в вашу консоль с помощью Python и модуля colorama. Если вы устали от скучного черно-белого вывода, держитесь — сейчас будет ярко!

## Почему вообще нужен цвет в терминале?

Отвечу просто: цвет помогает быстрее ориентироваться в выводе. Особенно, если ваш скрипт что-то сообщает пользователю или вы регулярно гоняете тесты. Красное — ошибка, желтое — предупреждение, зеленое — успех. Появляется ясность, стиль и чуть-чуть магии.

## Знакомимся с colorama

Модуль colorama отлично работает и на Windows, и на Unix-подобных системах. Установить его можно так:

pip install colorama

Подключаем:

from colorama import init, Fore, Back, Style
init()

init() — это стандартная команда, чтобы цвета корректно работали в Windows.

## Пример 1: Цветной текст

Всё просто:

from colorama import Fore, Style, init
init()

print(Fore.RED + 'Error: Invalid input!')
print(Fore.GREEN + 'Success: Operation completed.')
print(Style.RESET_ALL + 'Back to default color.')

Как видно, Fore отвечает за цвет текста. Всё просто и понятно.

## Пример 2: Цветной фон и эффекты

Добавим цветной фон и немного форматирования:

from colorama import Fore, Back, Style, init
init()

print(Fore.YELLOW + Back.BLUE + 'Warning: Low memory!')
print(Style.BRIGHT + 'This text is bold!')
print(Style.RESET_ALL + 'Default style and color.')

Здесь Back — фон, а Style.BRIGHT делает текст более ярким. Не забываем сбрасывать стиль с Style.RESET_ALL, чтобы дальше вывод был обычным.

## Пример 3: Цвета в строках

Если нужно использовать цвета внутри составной строки:

from colorama import Fore, Style, init
init()

user = 'Alice'
print(f'{Fore.CYAN}Hello, {user}!{Style.RESET_ALL}')

Цвет работает и в f-строках, что очень удобно.

## Итоги

colorama позволяет буквально за пару строк сделать консольный вывод современнее и нагляднее. Здесь нет хитрых настроек, всё интуитивно: Fore — цвет текста, Back — фон, Style — стиль. Хочется выделять информацию? Применяйте colorama и управляйте вниманием пользователей!

До новых ярких идей!
— Иван