Создание простого чат-сервера с использованием сокетов

Создаем простой чат-сервер на сокетах: от нуля до мини-мессенджера

Сокеты — это базовый способ общения программ по сети. Без них не было бы ни браузеров, ни мессенджеров, ни онлайн-игр. Давай сделаем свой простой чат-сервер на Python и поймем, как это работает изнутри.

---

## Базовая идея

Нам нужны две части:

1. Сервер — ждет подключения клиентов и пересылает сообщения.
2. Клиент — подключается к серверу и отправляет/получает сообщения.

Используем стандартный модуль socket, ничего дополнительно устанавливать не нужно.

---

## Простой сервер

Этот сервер:
- принимает несколько клиентов,
- читает от каждого сообщения,
- рассылает их всем остальным.

import socket
import threading

HOST = "127.0.0.1"
PORT = 5000

clients = []

def broadcast(message, sender_sock):
    for client in clients:
        if client is not sender_sock:
            try:
                client.sendall(message)
            except OSError:
                pass

def handle_client(client_sock, addr):
    print(f"Connected: {addr}")
    while True:
        try:
            data = client_sock.recv(1024)
            if not data:
                break
            broadcast(data, client_sock)
        except ConnectionResetError:
            break
    print(f"Disconnected: {addr}")
    clients.remove(client_sock)
    client_sock.close()

def run_server():
    server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_sock.bind((HOST, PORT))
    server_sock.listen()
    print(f"Server listening on {HOST}:{PORT}")

    while True:
        client_sock, addr = server_sock.accept()
        clients.append(client_sock)
        thread = threading.Thread(target=handle_client, args=(client_sock, addr), daemon=True)
        thread.start()

if __name__ == "__main__":
    run_server()

Ключевые моменты:
- socket.AF_INET, socket.SOCK_STREAM — TCP-соединение по IPv4.
- listen() — сервер готов принимать соединения.
- Для каждого клиента создаем поток, чтобы они не блокировали друг друга.

---

## Простой клиент

Подключаемся к серверу и читаем/пишем сообщения одновременно.

import socket
import threading

HOST = "127.0.0.1"
PORT = 5000

def receive_messages(sock):
    while True:
        try:
            data = sock.recv(1024)
            if not data:
                print("Connection closed by server")
                break
            print(">>", data.decode("utf-8"))
        except OSError:
            break

def run_client():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((HOST, PORT))
    print("Connected to chat server")

    thread = threading.Thread(target=receive_messages, args=(sock,), daemon=True)
    thread.start()

    try:
        while True:
            msg = input()
            if msg.lower() == "/quit":
                break
            sock.sendall(msg.encode("utf-8"))
    finally:
        sock.close()

if __name__ == "__main__":
    run_client()

---

## Что можно улучшить дальше

- Добавить никнеймы и формат сообщений ([user]: text).
- Логировать чаты в файл.
- Использовать asyncio вместо потоков для масштабируемости.

Но уже сейчас ты сделал основу своего мини-мессенджера на чистых сокетах — без магии, только протокол TCP и немного кода.

Изучение простейших графов с помощью модуля graphlib

Изучаем простейшие графы с помощью модуля graphlib

Когда слышишь «графы», кажется, что это что‑то из теории алгоритмов для олимпиадников. Но в Python уже есть готовый инструмент для работы с простыми графами — модуль graphlib, который появился в версии 3.9. И использовать его можно прямо «из коробки», без сторонних библиотек.

### Что за модуль graphlib?

В graphlib есть класс TopologicalSorter. Он работает с ориентированными ациклическими графами (DAG) и умеет:

- проверять, есть ли циклы;
- выполнять топологическую сортировку (определять порядок выполнения задач с зависимостями);
- пошагово «выстреливать» вершины, которые уже можно обработать.

Граф здесь задаётся как зависимости: указываем, какие вершины зависят от каких.

### Простейший пример: порядок задач

Представим, что нам нужно выстроить порядок задач с зависимостями:

from graphlib import TopologicalSorter

graph = {
    "cook_pasta": {"buy_products"},
    "make_sauce": {"buy_products"},
    "serve_dinner": {"cook_pasta", "make_sauce"},
    "buy_products": set(),
}

ts = TopologicalSorter(graph)
order = list(ts.static_order())
print(order)

Вывод будет чем‑то вроде:

['buy_products', 'cook_pasta', 'make_sauce', 'serve_dinner']

Мы получили корректный порядок выполнения без единого if и хитрых циклов.

Важно: если в графе есть цикл, static_order() выбросит CycleError. Это удобно для проверки зависимостей.

### Пошаговая обработка: имитация планировщика

TopologicalSorter можно использовать как мини‑движок для планировщика задач:

from graphlib import TopologicalSorter

graph = {
    "download_data": set(),
    "clean_data": {"download_data"},
    "train_model": {"clean_data"},
    "evaluate_model": {"train_model"},
}

ts = TopologicalSorter(graph)
ts.prepare()

while ts.is_active():
    ready_tasks = ts.get_ready()
    for task in ready_tasks:
        print(f"Running: {task}")
        # Здесь могла бы быть реальная работа
        ts.done(task)

Методы:

- prepare() — инициализация процесса;
- get_ready() — вернуть все вершины, у которых уже выполнены зависимости;
- done(node) — сообщить, что вершина обработана;
- is_active() — есть ли ещё работа.

Так можно, например, отправлять независимые задачи в разные потоки или процессы.

### Мини‑валидатор зависимостей

Ещё один практичный сценарий — проверка корректности конфигураций:

from graphlib import TopologicalSorter, CycleError

def validate_dependencies(dep_graph: dict) -> bool:
    try:
        TopologicalSorter(dep_graph).static_order()
        return True
    except CycleError as e:
        print("Cycle detected:", e)
        return False

deps_ok = {
    "A": {"B"},
    "B": {"C"},
    "C": set(),
}

deps_bad = {
    "A": {"B"},
    "B": {"C"},
    "C": {"A"},
}

print(validate_dependencies(deps_ok))   # True
print(validate_dependencies(deps_bad))  # False + сообщение о цикле

Так всего парой строк можно защититься от «замкнувшихся» настроек.

---

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

Создание временного файла с модулем tempfile

Создание временного файла с модулем tempfile

Работа с файлами — обычное дело в Python: логи, отчёты, экспорт данных. Но часто файл нужен «на пару секунд» — что‑то записать, передать другой функции, а потом забыть. Создавать для этого реальные файлы в папке проекта неудобно и небезопасно. Здесь на сцену выходит модуль tempfile.

tempfile отвечает за создание временных файлов и папок в системном временном каталоге (подбирается автоматически под вашу ОС). Его главный плюс — безопасность и автоматическая уборка за собой.

---

### Простейший временный файл

Функция NamedTemporaryFile создаёт временный файл с именем, к которому можно обратиться как к обычному файлу:

import tempfile

with tempfile.NamedTemporaryFile(mode="w+", delete=True, suffix=".txt") as tmp_file:
    tmp_file.write("Some temporary data\n")
    tmp_file.flush()  # сбрасываем буфер на диск

    print("Temp file name:", tmp_file.name)

    tmp_file.seek(0)
    content = tmp_file.read()
    print("Content:", content)

# Здесь файл уже удалён автоматически

Ключевые моменты:

- mode="w+" — можно и писать, и читать.
- delete=True — файл будет удалён при выходе из with.
- suffix=".txt" — можно задать расширение (полезно для сторонних программ, ожидающих конкретный тип файла).
- tmp_file.name — реальный путь к файлу на диске.

---

### Временный файл без имени

Если имя файла не нужно (например, вы просто временно храните данные в пределах одного процесса), используйте TemporaryFile:

import tempfile

with tempfile.TemporaryFile(mode="w+") as tmp:
    tmp.write("Internal buffer\n")
    tmp.seek(0)
    print(tmp.read())

Такой файл может вообще не иметь «нормального» имени в файловой системе (зависит от ОС), зато всё ещё ведёт себя как обычный файловый объект.

---

### Где хранятся временные файлы?

Посмотреть каталог, который использует tempfile, можно так:

import tempfile
print(tempfile.gettempdir())

Обычно это что‑то вроде /tmp на Linux или C:\Users\<user>\AppData\Local\Temp на Windows.

---

### Зачем это нужно на практике?

- Генерация отчёта, который тут же отправляется по сети.
- Временное сохранение загруженного файла перед обработкой.
- Тестирование кода, работающего с файловой системой, без мусора в проекте.

tempfile позволяет писать код, который не оставляет следов, не конфликтует с существующими файлами и не требует ручной уборки. Для аккуратных Python‑разработчиков — must‑have инструмент.

Изучение интерфейса для очередей очередей с queue.Queue

Изучаем очередь задач с queue.Queue: безопасный обмен данными между потоками

Когда в программе появляется несколько потоков, один из первых вопросов — как безопасно передавать им данные. Глобальные списки и словари быстро превращают код в хаос. Для таких задач в стандартной библиотеке есть герой попроще и понадежнее — queue.Queue.

---

## Что такое queue.Queue?

Queue — это потокобезопасная структура данных «первым пришёл — первым вышел» (FIFO).
Главные свойства:

- безопасна для работы из нескольких потоков;
- умеет блокироваться при put() и get(), пока не появится место или элемент;
- поддерживает ограничение размера (maxsize), чтобы не «забить» память.

Подключается просто:

from queue import Queue

---

## Базовый пример: очередь задач

Допустим, у нас есть «производитель» задач и «потребитель», который их обрабатывает:

from queue import Queue
from threading import Thread
import time

def producer(task_queue, n_tasks):
    for i in range(n_tasks):
        task = f"task_{i}"
        print(f"Produce: {task}")
        task_queue.put(task)  # блокируется, если очередь заполнена
    task_queue.put(None)  # сигнал завершения

def consumer(task_queue):
    while True:
        task = task_queue.get()  # блокируется, пока очередь пуста
        if task is None:  # получили сигнал "конец"
            task_queue.task_done()
            break
        print(f"Consume: {task}")
        time.sleep(0.2)  # имитация работы
        task_queue.task_done()

def main():
    task_queue = Queue(maxsize=5)

    t_prod = Thread(target=producer, args=(task_queue, 10))
    t_cons = Thread(target=consumer, args=(task_queue,))

    t_prod.start()
    t_cons.start()

    task_queue.join()  # ждём, пока все задачи будут обработаны
    t_prod.join()
    t_cons.join()

if __name__ == "__main__":
    main()

Ключевые моменты:

- put() и get() по умолчанию блокирующие;
- task_done() говорит очереди: «элемент обработан»;
- join() блокируется, пока количество task_done() не сравняется с количеством put().

---

## Неблокирующий режим и таймауты

Иногда блокироваться нельзя:

from queue import Queue, Empty, Full

q = Queue(maxsize=2)

try:
    q.put("item1", block=False)
    q.put("item2", block=False)
    q.put("item3", timeout=0.5)  # подождём немного
except Full:
    print("Queue is full!")

try:
    item = q.get(block=False)
    print("Got:", item)
    item = q.get(timeout=0.5)
except Empty:
    print("Queue is empty!")

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

---

## Когда использовать queue.Queue

- Обработка задач в нескольких потоках (скачивание файлов, парсинг страниц).
- Логирование из разных потоков в один обработчик.
- Поток-производитель (сбор данных) и поток-потребитель (анализ, запись в БД).

Главный плюс: Queue берет на себя всю головную боль с блокировками и синхронизацией. Вам остается думать о логике задач, а не о том, как не устроить гонку данных и дедлок.

Создание zip-архива и добавление файлов средствами shutil и zipfile

Создание zip-архива и добавление файлов средствами shutil и zipfile

Работа с архивами — один из тех навыков, которые рано или поздно нужны любому Python-разработчику. Сделать резервную копию проекта, упаковать отчёты, автоматически отправить архив по почте — всё это удобно делать прямо из кода. В стандартной библиотеке есть два ключевых инструмента: shutil и zipfile. Разберём оба.

---

## Вариант 1: Быстрое сжатие папки через shutil

shutil хорош, когда нужно просто взять каталог и превратить его в zip-архив, не вдаваясь в детали.

import shutil
from pathlib import Path

base_dir = Path("project_data")
archive_name = "project_backup"  # без расширения

# Создаст файл project_backup.zip с содержимым папки project_data
archive_path = shutil.make_archive(
    base_name=archive_name,
    format="zip",
    root_dir=base_dir
)

print(f"Archive created: {archive_path}")

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

---

## Вариант 2: Тонкий контроль через zipfile

Когда нужно добавлять файлы по одному, менять путь внутри архива, докладывать файлы позже — пригодится zipfile.

### Создание архива и добавление файлов

import zipfile
from pathlib import Path

zip_path = Path("reports.zip")

files_to_add = [
    Path("reports/january.csv"),
    Path("reports/february.csv"),
]

with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
    for file_path in files_to_add:
        arc_name = file_path.name  # как файл будет называться внутри архива
        zf.write(file_path, arcname=arc_name)

print(f"Created: {zip_path}")

### Дозапись файлов в существующий архив

import zipfile
from pathlib import Path

zip_path = Path("reports.zip")

with zipfile.ZipFile(zip_path, mode="a", compression=zipfile.ZIP_DEFLATED) as zf:
    zf.write("reports/march.csv", arcname="march.csv")

---

## Чтение и извлечение содержимого

import zipfile

with zipfile.ZipFile("reports.zip", mode="r") as zf:
    print("Files in archive:")
    for name in zf.namelist():
        print(" -", name)

    # Извлечь всё в папку extracted_reports
    zf.extractall("extracted_reports")

---

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

- shutil.make_archive — когда нужно быстро заархивировать каталог целиком.
- zipfile.ZipFile — когда нужен контроль: выборочные файлы, особые имена внутри архива, дозапись, чтение без распаковки.

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

Работа со временем: tzinfo и pytz для часовых поясов

Работа со временем в Python: tzinfo и pytz без магии и боли

Если вы хоть раз пытались работать с часовыми поясами, вы знаете: это ад из смещений, переходов на летнее время и странных правил разных стран. Но Python умеет в это неплохо — если правильно пользоваться tzinfo и библиотекой pytz.

---

### Наивные и осознанные datetime

По умолчанию datetime в Python не знает, в каком он часовом поясе.

from datetime import datetime

dt_naive = datetime(2024, 4, 5, 12, 0, 0)
print(dt_naive.tzinfo)  # None

Это наивный объект — он не привязан ни к одному поясу. Любая арифметика и сравнения с другими датами могут быть некорректны, если вы смешиваете разные пояса.

---

### Интерфейс tzinfo

Класс tzinfo — это абстракция часового пояса. В теории вы можете написать свой класс, унаследованный от tzinfo, который определит:

- utcoffset() — смещение от UTC
- dst() — переход на летнее время
- tzname() — имя пояса

Но на практике руками это почти никогда не делают: слишком много нюансов. Поэтому используется pytz.

---

### Подключаем pytz

Устанавливаем:

pip install pytz

Простой пример: берём локальное время в Москве и переводим его в Нью-Йорк.

from datetime import datetime
import pytz

tz_moscow = pytz.timezone("Europe/Moscow")
tz_ny = pytz.timezone("America/New_York")

dt_naive = datetime(2024, 4, 5, 12, 0, 0)

dt_moscow = tz_moscow.localize(dt_naive)
dt_ny = dt_moscow.astimezone(tz_ny)

print(dt_moscow, dt_moscow.tzinfo)  # 2024-04-05 12:00:00+03:00
print(dt_ny, dt_ny.tzinfo)          # 2024-04-05 05:00:00-04:00

Ключевой момент — никогда не делать так:

# ПЛОХО
dt_wrong = datetime(2024, 4, 5, 12, 0, 0, tzinfo=tz_moscow)

С pytz это ломает обработку переходов на летнее время. Нужно именно localize().

---

### Храним в UTC, показываем пользователю в его поясе

Золотое правило: хранить время в UTC, показывать — в локальном часовом поясе.

from datetime import datetime
import pytz

utc = pytz.utc
tz_user = pytz.timezone("Asia/Tokyo")

# допустим, это пришло из БД как UTC
dt_stored = datetime(2024, 4, 5, 9, 0, 0, tzinfo=utc)

dt_user = dt_stored.astimezone(tz_user)
print("UTC:", dt_stored)
print("User time:", dt_user)

Так вы избегаете боли при переносе данных между сервером, БД и пользователями из разных стран.

---

### Подводные камни: неоднозначные и несуществующие времена

При переходах на зимнее/летнее время могут быть:

- Неоднозначные моменты (1:30 случается дважды)
- Несуществующие моменты (стрелка перепрыгивает через 2:00–3:00)

pytz умеет это обрабатывать через параметр is_dst:

from datetime import datetime
import pytz

tz = pytz.timezone("America/New_York")
dt_naive = datetime(2024, 11, 3, 1, 30, 0)  # переход на зимнее время

dt_first = tz.localize(dt_naive, is_dst=True)   # "летняя" 1:30
dt_second = tz.localize(dt_naive, is_dst=False) # "зимняя" 1:30

print(dt_first)
print(dt_second)

---

### Вывод

- Используйте tzinfo, но руками его не реализуйте — для реального мира берите pytz.
- Делайте localize() для привязки наивного datetime к поясу.
- Всегда храните время в UTC, а отображайте в нужной зоне через astimezone().
- Будьте осторожны с переходами на летнее/зимнее время — они реально ломают голову, но pytz знает все правила.

Создание простого будильника с помощью модуля time

### Создаём простой будильник на Python с помощью модуля time

Когда только начинаешь учить Python, хочется писать что‑то полезное, а не только складывать числа в консоли. Давай сделаем простой будильник — без графики, без музыки, но с чёткой логикой и полезным знакомством с модулем time.

---

## Модуль time в двух словах

Главные функции, которые нам пригодятся:

- time.time() — возвращает текущее время в секундах с 1 января 1970 года.
- time.sleep(seconds) — “усыпляет” программу на заданное количество секунд.
- time.strftime(format) — возвращает текущие дату и время в удобном форматe.

---

## Будильник по времени в формате HH:MM

Идея простая:
1. Пользователь вводит время будильника.
2. Программа регулярно проверяет текущее время.
3. Когда часы и минуты совпадают — срабатывает будильник.

import time

def get_current_time_str():
    return time.strftime("%H:%M")

alarm_time = input("Enter alarm time (HH:MM): ")

print(f"Alarm is set for {alarm_time}. Waiting...")

while True:
    now = get_current_time_str()
    if now == alarm_time:
        print("WAKE UP! Alarm time reached!")
        break
    time.sleep(10)

Что здесь важно:

- time.strftime("%H:%M") возвращает строку вида 14:05.
- Мы сравниваем строку текущего времени с введённой строкой — просто и удобно.
- time.sleep(10) снижает нагрузку на процессор: мы проверяем время раз в 10 секунд, а не бесконечно крутим цикл.

---

## Будильник с задержкой в секундах

Иногда нужно “разбудить” себя (или программу) через N секунд:

import time

delay = int(input("Enter delay in seconds: "))
print(f"Timer set for {delay} seconds...")

time.sleep(delay)

print("TIME IS UP!")

Здесь мы используем только time.sleep(), но это уже рабочий таймер.

---

## Немного улучшений

- Можно сделать звуковой сигнал с помощью системных команд (winsound на Windows или os.system("play ...") на Linux), но это уже следующий шаг.
- Можно дать возможность вводить и дату, и время, затем сравнивать через time.strptime() и time.mktime() — получится почти мини‑календарь.

---

Мы использовали всего один модуль — time, а уже получили два рабочих инструмента: будильник по часам и таймер по секундам. Отличный пример того, как из простых функций собрать полезный скрипт.

Работа с мультипроцессорностью с помощью модуля multiprocessing

Работа с мультипроцессорностью в Python: модуль multiprocessing

Если ваш скрипт считает что‑то «тяжёлое» и при этом использует только одно ядро процессора — он просто ленится. Модуль multiprocessing позволяет загрузить все ядра и реально ускорить выполнение CPU‑интенсивных задач.

---

### Почему не threading?

В Python есть GIL — глобальная блокировка интерпретатора. Потоки (threading) отлично подходят для I/O (сетевые запросы, файлы), но почти не ускоряют чистые вычисления: байткод всё равно исполняется в один поток.

multiprocessing запускает несколько процессов, у каждого свой интерпретатор и свой GIL. Значит, они могут работать параллельно на разных ядрах.

---

### Простой пример: распараллеливаем вычисления

Допустим, у нас есть тяжёлая функция:

from multiprocessing import Process
import time

def heavy_job(n):
    s = 0
    for i in range(10_000_000):
        s += (i * n) % 7
    print(f"Result for {n}: {s}")

if __name__ == "__main__":
    t0 = time.time()

    processes = []
    for num in [1, 2, 3, 4]:
        p = Process(target=heavy_job, args=(num,))
        p.start()
        processes.append(p)

    for p in processes:
        p.join()

    print("Time:", time.time() - t0)

Ключевые моменты:

- if __name__ == "__main__": обязателен на Windows и macOS, иначе процессы начнут бесконечно плодиться.
- Process(target=..., args=...) — создаём процесс и указываем функцию.
- start() — запускаем, join() — ждём завершения.

Каждый процесс считает свою версию heavy_job, ядра загружаются параллельно.

---

### Используем пул процессов: Pool

Чаще всего нужно применить одну функцию к множеству входных данных. Для этого идеален Pool.

from multiprocessing import Pool
import time

def square(x):
    return x * x

if __name__ == "__main__":
    data = list(range(10))

    t0 = time.time()
    with Pool(processes=4) as pool:
        result = pool.map(square, data)
    print("Result:", result)
    print("Time:", time.time() - t0)

Что важно:

- Pool сам управляет созданием и завершением процессов.
- map работает примерно как встроенная map, только параллельно.
- Функция, передаваемая в процессы, должна быть определена на верхнем уровне модуля (не внутри другой функции, не lambda).

---

### Передача данных между процессами

У процессов своя память, поэтому обычные переменные не разделяются. Можно использовать:

- Queue — безопасная очередь для обмена сообщениями.
- Manager — создаёт объекты, которые можно разделять (списки, словари).

Пример с Queue:

from multiprocessing import Process, Queue

def worker(q, x):
    q.put(x * 2)

if __name__ == "__main__":
    q = Queue()
    processes = []

    for i in range(5):
        p = Process(target=worker, args=(q, i))
        p.start()
        processes.append(p)

    for p in processes:
        p.join()

    results = [q.get() for _ in range(5)]
    print(results)

---

multiprocessing — это способ превратить ваш скрипт в мини‑кластер на одном компьютере. Если задача упирается в процессор, а не в диск или сеть, имеет смысл попробовать распараллеливание: часто выигрыш по времени оказывается впечатляющим.

Создание локального чат-бота используя модуль socket

Создаем локального чат-бота на Python с помощью socket

Локальный чат-бот — это отличный способ понять, как устроены сетевые приложения: клиент, сервер, обмен сообщениями. Без веб-фреймворков и магии — только socket и немного логики.

---

### Идея

Мы сделаем простой консольный чат-бот:

- Сервер: ждет подключений, принимает сообщения и отвечает.
- Клиент: подключается к боту и общается с ним в одном терминале.

Работать будем только на localhost, без выхода в интернет.

---

### Шаг 1. Простейший сервер-бот

Сервер слушает порт, принимает соединение и в цикле отвечает пользователю.

# server.py
import socket

HOST = "127.0.0.1"
PORT = 5000

def generate_reply(message: str) -> str:
    message = message.lower()
    if "hello" in message:
        return "Hi! I'm your local socket bot."
    if "help" in message:
        return "Try: hello, time, bye."
    if "time" in message:
        from datetime import datetime
        return f"Current time: {datetime.now().strftime('%H:%M:%S')}"
    if "bye" in message:
        return "Goodbye! Closing connection."
    return "I don't understand. Type 'help'."

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(1)
    print(f"Bot is listening on {HOST}:{PORT}...")
    conn, addr = s.accept()
    with conn:
        print(f"Connected by {addr}")
        while True:
            data = conn.recv(1024)
            if not data:
                break
            user_msg = data.decode("utf-8")
            reply = generate_reply(user_msg)
            conn.sendall(reply.encode("utf-8"))
            if "bye" in user_msg.lower():
                break

---

### Шаг 2. Клиент для общения с ботом

# client.py
import socket

HOST = "127.0.0.1"
PORT = 5000

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    print("Connected to local bot. Type messages, 'bye' to exit.")
    while True:
        user_msg = input("> ")
        s.sendall(user_msg.encode("utf-8"))
        data = s.recv(1024)
        bot_reply = data.decode("utf-8")
        print("Bot:", bot_reply)
        if "bye" in user_msg.lower():
            break

---

### Что здесь важно понять

1. socket.AF_INET, socket.SOCK_STREAM — обычный TCP-сокет.
2. bind + listen + accept — базовый цикл сервера.
3. sendall и recv — протокол обмена байтами; мы сами решаем, во что их превращать (здесь — строки UTF-8).
4. Локальный бот можно усложнять:
- добавлять обработку команд,
- сохранять историю диалога,
- подключать простейший ИИ или правила.

Такой минималистичный проект отлично прокачивает понимание сетей и одновременно дает живой, работающий результат — своего собственного чат-бота, полностью под вашим контролем.

Как задать формат вывода дат с помощью strftime

Как укротить дату в Python: форматирование с strftime

У datetime в Python есть суперспособность — превращать «сырую» дату в аккуратную строку нужного формата. Делает он это с помощью метода strftime. Запомните: string format time.

Начнем с базы:

from datetime import datetime

now = datetime.now()
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)  # например: 2026-04-09 14:37:12

strftime принимает строку-шаблон, где специальные %-коды заменяются на кусочки даты и времени.

### Самые полезные коды формата

Вот минимальный «набор выживания»:

- %Y — год полностью, 2026
- %y — год из двух цифр, 26
- %m — месяц, 01–12
- %d — день месяца, 01–31
- %H — часы (24-часовой формат), 00–23
- %M — минуты, 00–59
- %S — секунды, 00–59

Комбинируя их, можно получить любой стиль:

from datetime import datetime

now = datetime.now()

iso_style = now.strftime("%Y-%m-%d")
europe_style = now.strftime("%d.%m.%Y")
us_style = now.strftime("%m/%d/%Y")
time_only = now.strftime("%H:%M")

print(iso_style)
print(europe_style)
print(us_style)
print(time_only)

### День недели и месяц словами

Если нужно что-то «человечнее», вроде «Thu, April 09, 2026»:

- %a — краткое название дня недели (Mon)
- %A — полное название дня недели (Monday)
- %b — краткое название месяца (Apr)
- %B — полное название месяца (April)

from datetime import datetime

now = datetime.now()

pretty = now.strftime("%A, %d %B %Y, %H:%M")
log_style = now.strftime("[%Y-%m-%d %H:%M:%S]")

print(pretty)
print(log_style)

### Формат для логов и файлов

Частая задача — сделать «безопасное» имя файла с датой внутри (никаких пробелов и двоеточий):

from datetime import datetime

now = datetime.now()

filename = now.strftime("backup_%Y%m%d_%H%M%S.zip")
print(filename)  # например: backup_20260409_143712.zip

### Маленький лайфхак

Если увидели где-то странную строку вида 2026-04-09T14:37:12 — это почти ISO 8601. Такое легко получить:

from datetime import datetime

now = datetime.now()
iso_like = now.strftime("%Y-%m-%dT%H:%M:%S")
print(iso_like)

strftime — это ваш личный дизайнер дат. Один и тот же объект datetime, но десятки разных представлений — под логи, интерфейсы, имена файлов и отчеты. Главное — выучить несколько кодов, а остальное легко комбинировать как конструктор.