🕹️ Как создать простую текстовую игру с помощью модуля curses в Python

Привет! С вами Иван, и сегодня мы окунёмся в мир текстовых интерфейсов на чистом Python. Игры — отличный способ попрактиковаться в программировании. А текстовые игры — это минимум графики, максимум фантазии. Но даже текст можно приукрасить: анимацией, управлением клавишами и взаимодействием в реальном времени. Всё это даёт модуль curses.

Что такое curses?

Модуль curses — это оболочка для работы с терминалом. Он позволяет рисовать "на лету", обрабатывать нажатия клавиш без ENTER'а, управлять цветами и позициями текста, и всё это — удобно, не покидая консолей. Работает из коробки на Linux и macOS. На Windows потребуется установить windows-curses:

pip install windows-curses

Создаём простую игру: уклоняйся от падающих звёзд 🌠

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

Давайте напишем минимальную, но полностью работающую аркаду на curses:

import curses
import random
import time

def main(stdscr):
    curses.curs_set(0)
    stdscr.nodelay(True)
    stdscr.timeout(100)

    sh, sw = stdscr.getmaxyx()
    player_x = sw // 2
    player = "🙂"
    stars = []
    score = 0

    while True:
        stdscr.clear()

        # Рисуем игрока
        stdscr.addstr(sh - 1, player_x, player)

        # Генерация новых звезд
        if random.randint(1, 10) == 1:
            star_x = random.randint(0, sw - 1)
            stars.append([0, star_x])

        # Обновляем позиции звезд
        for star in stars:
            star[0] += 1
            if star[0] < sh:
                stdscr.addstr(star[0], star[1], "*")

        # Проверка на столкновение
        for star in stars:
            if star[0] == sh - 1 and star[1] == player_x:
                msg = f"Game Over! Score: {score}"
                stdscr.addstr(sh // 2, sw // 2 - len(msg) // 2, msg)
                stdscr.refresh()
                time.sleep(2)
                return

        # Удаляем вышедшие за границу звезды и увеличиваем счёт
        stars = [star for star in stars if star[0] < sh]
        score += 1

        # Управление
        key = stdscr.getch()
        if key == curses.KEY_LEFT and player_x > 0:
            player_x -= 1
        elif key == curses.KEY_RIGHT and player_x < sw - 1:
            player_x += 1
        elif key == ord('q'):
            break

        stdscr.refresh()

curses.wrapper(main)

📦 Что мы здесь используем:

- nodelay(True) и timeout(100) — для плавного обновления экрана;
- curs_set(0) — отключение мигающего курсора;
- getch() — для чтения нажатий клавиш без ENTER'а;
- addstr(y, x, text) — вывод текста в нужную позицию;
- getmaxyx() — узнаем размеры терминала;

🔥 Игра проста, но в ней уже есть движение, случайность, управление и счёт. На этой базе можно развивать игру: добавить жизни, уровни или спецэффекты.

Если вы устали от обычных input/print — попробуйте curses. Он идеален для создания собственных мини-игр, TUI-интерфейсов, и просто для фана.

До встречи в следующем посте. Будем учиться строить терминальное меню и прокачаем наши игрушки! 👾

Использование namedtuple для более читаемого кода

Когда кортеж — хорошо, но читаемость важнее: знакомимся с namedtuple

Когда-то каждый из нас начинал с простых структур данных в Python: списков, словарей и кортежей. Но вот беда — кортежи хоть и компактны, но напрочь забывают об удобстве чтения. Спустя пару недель ты смотришь на что-то вроде tuple2 и пытаешься вспомнить, был ли это адрес, возраст или погрешность измерения.

А теперь представь — можно оставить легковесность, но добавить читаемость. Волшебство? Почти. Это namedtuple.

📦 Что такое namedtuple?

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

from collections import namedtuple

Выглядит как класс, работает как кортеж. Удобно, быстро и читаемо.

🚀 Создаем первый namedtuple

Допустим, мы пишем GPS-трекер. Точка на карте содержит имя координаты, широту и долготу. Можно сделать это так:

from collections import namedtuple

Location = namedtuple('Location', ['name', 'latitude', 'longitude'])

place = Location(name='Home', latitude=55.750446, longitude=37.617494)

print(place)
print(place.name)         # 'Home'
print(place.latitude)     # 55.750446

Уже лучше, чем tuple0, правда? А еще у такого объекта сохраняется понятная структура при выводе и его можно распаковывать как обычный кортеж:

name, lat, lon = place

✨ Не только красиво, но и полезно

Из коробки namedtuple дает такие плюшки:

- Легковесность как у tuple (namedtuple неизменяем);
- Поддержка всех tuple-операций: индексация, распаковка, сравнение;
- Метод asdict() — для превращения в словарь;
- Метод replace() — для создания новой копии с измененными полями.

Пример:

updated_place = place._replace(name='Office')

print(place.name)         # 'Home'
print(updated_place.name) # 'Office'

А вот превращение в словарь удобно, если нужно, скажем, сериализовать:

print(place._asdict())
# {'name': 'Home', 'latitude': 55.750446, 'longitude': 37.617494}

🧩 Когда использовать?

Используй namedtuple, когда:

1. У объекта фиксированное количество атрибутов;
2. Ты хочешь неизменяемые структуры;
3. Нужна читаемость при минимальных затратах памяти.

Для mutable-объектов лучше подойдет dataclass, но это уже другая история.

🤹 Чуть больше магии

namedtuple позволяет указывать значения по умолчанию (не напрямую, но можно немного схитрить):

Color = namedtuple('Color', ['r', 'g', 'b'], defaults=[0, 0, 0])

gray = Color()
print(gray)  # Color(r=0, g=0, b=0)

Эта фича доступна, начиная с Python 3.7.

🔚 Итоги

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

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

Как настроить FTP соединение с использованием модуля ftplib

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

Модуль ftplib входит в стандартную библиотеку Python, так что ничего дополнительно устанавливать не нужно. Давайте сразу начнем с базового подключения.

## Подключаемся к FTP-серверу

Для начала, создадим соединение и получим список файлов:

from ftplib import FTP

ftp = FTP('ftp.example.com')  # Адрес сервера
ftp.login(user='username', passwd='password')

ftp.cwd('/path/to/directory')  # Переход в нужную директорию
files = ftp.nlst()  # Получаем список файлов
print(files)

ftp.quit()

Метод login() используется для авторизации. Если сервер поддерживает анонимный доступ, просто вызовите ftp.login() без параметров. Метод nlst() возвращает список имен файлов в текущей директории.

## Скачиваем файл

Хотите скачать файл — скажем, data.txt? Легко:

with open('data.txt', 'wb') as f:
    ftp.retrbinary('RETR data.txt', f.write)

Метод retrbinary() хорош для двоичных данных (например, изображений). Если вы уверены, что работаете с текстом, можно использовать retrlines():

ftp.retrlines('RETR readme.txt', lambda line: print(">>", line))

## Загружаем файл

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

with open('upload.txt', 'rb') as f:
    ftp.storbinary('STOR upload.txt', f)

Метод storbinary() отправляет двоичный файл на сервер. Если нужно передать файл построчно, используйте storlines().

## Полезные фишки

- ftp.cwd(path) — смена директории на сервере.
- ftp.mkd(dirname) и ftp.rmd(dirname) — создать и удалить директорию.
- ftp.delete(filename) — удалить файл.
- ftp.rename(old, new) — переименовать файл или переместить.

Пример: создадим папку и загрузим туда файл.

ftp.mkd('new_folder')
ftp.cwd('new_folder')

with open('photo.jpg', 'rb') as f:
    ftp.storbinary('STOR photo.jpg', f)

## Немного безопасности

FTP — это не самый защищённый протокол. Данные передаются в открытом виде, без шифрования. Если работаете с чувствительной информацией — рассмотрите ftplib.FTP_TLS, чтобы использовать FTPS.

from ftplib import FTP_TLS

ftp = FTP_TLS('secure.example.com')
ftp.login('user', 'password')
ftp.prot_p()  # Включаем защиту данных

## В заключение

Модуль ftplib — это отличный способ автоматизировать работу с файлами на удалённых серверах. Он незаменим, если вы, например, хотите написать скрипт, который каждый день сохраняет бэкапы или забирает отчеты с FTP-серверов. Всё просто: минимум кода, максимум полезности.

До встречи в следующих постах!
Ваш Иван 🐍

Изучение параметров командной строки: модуль argparse в действии

Привет! На связи Иван, и сегодня поговорим о том, как научить свои скрипты понимать команды из терминала. Представь: ты написал крутую утилиту, и теперь хочешь запускать её с разными параметрами, а не каждый раз менять код или жонглировать 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 для пакетов