Создание простых 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 и управляйте вниманием пользователей!

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

Подключение к POP3 серверам для обработки электронной почты

Привет! Я Иван, и сегодня мы с тобой шагнем в загадочный мир работы с электронной почтой из Python – научимся подключаться к POP3-серверам! Почему это важно? Иногда автоматическая обработка почты нужна для создания ботов, триггеров или просто творческих проектов.

POP3 – это популярный протокол, позволяющий "забирать" письма с серверов электронной почты. Для работы с ним есть стандартный модуль poplib. Давай разберём его на практике.

### 1. Установка соединения

import poplib

server = poplib.POP3_SSL('pop.gmail.com', 995)
server.user('your_email@gmail.com')
server.pass_('your_app_password')

В современных почтовиках, например Gmail, потребуется пароль приложения (генерируется в настройках безопасности).

### 2. Получаем список писем

num_messages = len(server.list()[1])
print(f'You have {num_messages} messages.')

server.list() возвращает список всех писем в почтовом ящике.

### 3. Читаем первое письмо

resp, lines, octets = server.retr(1)  # 1 — это номер письма
message_content = b'\n'.join(lines).decode('utf-8')
print(message_content)

retr(n) берёт письмо по номеру. Письмо возвращается в виде списка байтовых строк (lines), которые мы соединяем и декодируем.

### 4. Завершаем сессию

server.quit()

---

В реальных задачах удобно обрабатывать письма не по номерам, а в цикле, или искать определённые заголовки. Также для красивого разбора структуры письма пригодятся модули email и re – но об этом уже в другой раз.

Совет: Проверяй настройки безопасности почтового ящика! Иногда нужно разрешить подключение со сторонних приложений.

Работа с POP3 – открывает путь к автоматизации и аналитике писем (например, уведомлений о заказах или сообщений от пользователей). Удачного кодинга и до скорых встреч!

Работа с мониторингом системы с помощью модуля psutil

Привет, это Иван! Сегодня поговорим о полезном инструменте для любого начинающего питониста — модуле psutil. Если ты когда-нибудь хотел узнать, сколько “ест” памяти твоя программа, сколько у тебя свободного места на диске или какой у тебя загруженный процессор, psutil поможет всё это выяснить за пару строк кода.

psutil (process and system utilities) — универсальный модуль для мониторинга состояния системы. Он работает на Windows, Linux и даже на Mac, а API у него простой и интуитивный.

### Проверяем загрузку CPU

Начнём с самого интересного — сколько же процентов CPU сейчас используется?

import psutil

cpu_percent = psutil.cpu_percent(interval=1)
print(f"Current CPU load: {cpu_percent}%")

Всё просто: cpu_percent() анализирует загрузку процессора. Если поставить interval=1, функция замеряет занятость CPU за одну секунду.

### Смотрим на память

Хотите выяснить, сколько оперативки свободно? Легко:

import psutil

memory = psutil.virtual_memory()
print(f"Total: {memory.total // (1024**2)} MB")
print(f"Available: {memory.available // (1024**2)} MB")
print(f"Used: {memory.used // (1024**2)} MB")

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

### Местоположение под контроль: мониторим пространство на диске

Нужно узнать, сколько осталось свободного места на диске C? Вот вам пример:

import psutil

disk = psutil.disk_usage('C:\\')
print(f"Total: {disk.total // (1024**3)} GB")
print(f"Free: {disk.free // (1024**3)} GB")

Подставляйте свой путь для Linux или MacOS — будет также работать.

### Выводим процессы — что там работает?

Ещё одна фишка psutil — просмотр процессов:

import psutil

for proc in psutil.process_iter(['pid', 'name', 'username']):
    print(proc.info)

Скрипт покажет PID, имя процесса и его владельца для каждого рабочего приложения.

---

psutil — это мгновенный способ получить максимум информации о вашей системе и процессе выполнения вашего Python-кода. Этот модуль часто используют для создания системных мониторов или оптимизации работы программ. Советую попробовать провести “экскурсию” по системе с помощью psutil — и удивиться, сколько полезного можно узнать за пару строк!

Как создавать и использовать промежуточные слои в Flask

Привет! Я Иван, и сегодня мы разберём один из скрытых суперсил Flask — промежуточные слои, или middleware. Если вы пишете свой первый веб-сервис на Flask, то middleware покажутся чем-то загадочным. На самом деле, всё очень просто — это специальные функции, которые могут «подслушать» и даже изменить наш запрос или ответ до того, как он попадёт в маршрутизатор или пользователя.

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

В Flask есть два основных способа внедрить свои промежуточные слои.

## 1. before_request и after_request

Flask даёт встроенные хуки: можно выполнить что-то ДО и ПОСЛЕ основного обработчика запроса.

from flask import Flask, request

app = Flask(__name__)

@app.before_request
def log_request_info():
    print(f"Request: {request.method} {request.path}")

@app.after_request
def add_custom_header(response):
    response.headers['X-Powered-By'] = 'Python&Flask'
    return response

@app.route("/")
def home():
    return "Hello, world!"

В этом примере каждый запрос фиксируется, а в любом ответе появится особый HTTP-заголовок. Очень удобно!

## 2. Собственные WSGI middleware

Если хочется большего контроля, Flask позволяет оборачивать всё приложение сторонними слоями. Например, напишем свой простой middleware:

class SimpleMiddleware:
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        print("Middleware: request received")
        return self.app(environ, start_response)

app = Flask(__name__)
app.wsgi_app = SimpleMiddleware(app.wsgi_app)

@app.route("/secret")
def secret():
    return "This is secret!"

Здесь каждый HTTP-запрос «проходит» через наш класс, который может делать что угодно с данными.

## Вывод

Промежуточные слои — мощный инструмент, позволяющий работать с каждым запросом и ответом во Flask. Их применение открывает путь к гибкой авторизации, логированию, мониторингу и многому другому — и всё это не в ущерб чистоте главных обработчиков. Используйте middleware тогда, когда нужна общая логика для всего приложения!

— Иван

Использование модуля tkinter для создания простых калькуляторов

Привет, меня зовут Иван, и сегодня я расскажу, как быстро и просто создать свой калькулятор на Python с помощью модуля tkinter. Если вы ещё ни разу не работали с графическим интерфейсом — не пугайтесь! Всё проще, чем кажется.

Почему именно tkinter?
tkinter — это стандартный GUI-модуль, который поставляется с Python «из коробки». То есть ничего дополнительно устанавливать не надо. Он лёгкий, интуитивно понятный и идеально подходит для первых экспериментов с окнами, кнопками и текстовыми полями.

Идём к делу. Минимальный калькулятор

Создадим калькулятор, который умеет складывать два числа.

import tkinter as tk

def add_numbers():
    try:
        result = float(entry1.get()) + float(entry2.get())
        result_label.config(text=f"Result: {result}")
    except ValueError:
        result_label.config(text="Invalid input!")

root = tk.Tk()
root.title("Simple Calculator")

entry1 = tk.Entry(root)
entry1.pack()
entry2 = tk.Entry(root)
entry2.pack()

add_button = tk.Button(root, text="Add", command=add_numbers)
add_button.pack()

result_label = tk.Label(root, text="Result:")
result_label.pack()

root.mainloop()

Что тут происходит?
1. Создаём главное окно (root).
2. Добавляем два текстовых поля (entry1 и entry2).
3. Кнопка вызывает функцию add_numbers, которая берёт числа из полей, складывает их и выводит результат.

Сделаем лучше: универсальный калькулятор

Добавим операции: сложение, вычитание, умножение и деление.

def calculate(op):
    try:
        x = float(entry1.get())
        y = float(entry2.get())
        if op == "+":
            res = x + y
        elif op == "-":
            res = x - y
        elif op == "*":
            res = x * y
        elif op == "/":
            res = x / y if y != 0 else "Div by 0!"
        result_label.config(text=f"Result: {res}")
    except ValueError:
        result_label.config(text="Invalid input!")

frame = tk.Frame(root)
frame.pack()

for op in ("+", "-", "*", "/"):
    btn = tk.Button(frame, text=op, command=lambda o=op: calculate(o))
    btn.pack(side=tk.LEFT)

Теперь ваш калькулятор поддерживает все базовые арифметические операции! Можно поиграть с оформлением, добавить меню, вывести историю вычислений. Всё ограничивается только вашей фантазией — и возможностями tkinter.

tkinter — отличный способ почувствовать себя не только программистом, но и настоящим создателем цифровых инструментов. Начните с калькулятора, а там, глядишь, и свой планировщик задач напишете!

Как определить и использовать пользовательские исключения в Python

Привет! Меня зовут Иван, и сегодня я хочу поделиться с вами магией пользовательских исключений в Python. Все мы знаем, что Python обожает бросаться ошибками как ребёнок снежками. Но что делать, если стандартный арсенал исключений не справляется с уникальной ситуацией вашего кода?

### Зачем нужны пользовательские исключения?

Стандартные исключения (например, ValueError, TypeError) хороши, когда вы ловите что-то общее. Но когда ваш код сталкивается с чем-то специфическим ― например, вы пишете API для управления роботом-пылесосом и хотите выбрасывать ошибку, если пылесос застрял под диваном ― логичнее создать своё исключение.

### Как определить своё исключение

Пользовательские исключения наследуются от класса Exception. Это просто:

class VacuumStuckError(Exception):
    """Raised when the vacuum is stuck under the sofa."""
    pass

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

class VacuumStuckError(Exception):
    def __init__(self, location):
        self.location = location
        super().__init__(f"Vacuum is stuck at {self.location}")

### Используем пользовательские исключения

Когда возникает особая ситуация, вы просто используете raise:

def move_vacuum(location):
    forbidden_zones = ["sofa", "stairs"]
    if location in forbidden_zones:
        raise VacuumStuckError(location)
    print(f"Vacuum moving to {location}")

И ловим исключение как обычно:

try:
    move_vacuum("sofa")
except VacuumStuckError as e:
    print(f"Oops! {e}")

Результат:

Oops! Vacuum is stuck at sofa

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

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

Совет от меня: создавайте древовидную структуру своих исключений, наследуя их от одного корневого:

class VacuumError(Exception):
    pass

class VacuumStuckError(VacuumError):
    pass

class VacuumLowBatteryError(VacuumError):
    pass

Так проще поймать все ошибки, связанные с вашим оборудованием, одним блоком except VacuumError.

Пусть ваш код бросает только те снежки, которые вы сами для него подготовили!

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