Python для начинающих
1.06K subscribers
302 photos
3 videos
232 files
62 links
Python для начинающих
Download Telegram
### Основы работы с базами NoSQL: использование MongoDB с Python

Привет, друзья! Сегодня поговорим о работе с базами данных, но не с классическими реляционными, а с NoSQL. Разберем MongoDB, одну из самых популярных NoSQL-баз. Это идеальное решение для тех, кто ценит гибкость хранения данных и скорость разработки. А вишенка на этом пироге — подключение и работа с MongoDB через Python.

#### Что такое MongoDB и в чем ее фишка?

MongoDB — это база данных, которая хранит информацию не в таблицах (как, например, PostgreSQL или MySQL), а в виде документов в формате JSON (внутренне — BSON). Здесь нет строго фиксированной схемы, поэтому данные можно хранить с разной структурой внутри одной коллекции (аналог таблицы).

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

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

Сначала, конечно, установим саму базу данных. На сайте MongoDB можно скачать и установить сервер. Пакет для работы с MongoDB в Python называется pymongo. Устанавливаем его командой:

pip install pymongo


Поехали дальше?

#### Первое подключение к базе

Вот простой пример, как подключиться к MongoDB через pymongo и выполнить первую операцию:

from pymongo import MongoClient

# Подключаемся к серверу MongoDB (по умолчанию это localhost:27017)
client = MongoClient('mongodb://localhost:27017/')

# Создаем или подключаемся к существующей базе данных
db = client.my_database

# Создаем или подключаемся к коллекции
collection = db.my_collection

# Добавляем документ в коллекцию
data = {"name": "Alice", "age": 30, "email": "alice@example.com"}
collection.insert_one(data)

print("Document inserted!")


Вот так просто вы создали базу данных, коллекцию и добавили в нее первый документ!

#### Операции с документами: добавить, прочитать, обновить, удалить

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

1. Добавление нескольких документов

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

users = [
{"name": "Bob", "age": 25},
{"name": "Charlie", "age": 35, "email": "charlie@example.com"}
]
collection.insert_many(users)


2. Чтение данных

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

for user in collection.find():
print(user)


Или что-то выборочное:

result = collection.find_one({"name": "Alice"})
print(result)


3. Обновление документа

Обновим email для пользователя Alice:

collection.update_one(
{"name": "Alice"},
{"$set": {"email": "new_alice@example.com"}}
)


Обратите внимание на $set — это специальный оператор MongoDB для обновления только указанных полей.

4. Удаление документов

Удалить можно один документ или все, подходящие под условие:

# Удаляем одного пользователя по имени
collection.delete_one({"name": "Alice"})

# Удаляем всех, кто младше 30
collection.delete_many({"age": {"$lt": 30}})


#### Почему MongoDB — это круто?

- Гибкость структуры: забудьте про жесткую схему таблиц. Каждый документ может быть уникальным.
- Масштабируемость: MongoDB легко обрабатывает большие объемы данных и горизонтально масштабируется.
- Работа с JSON: если вы привыкли к обмену данными через JSON, работать будет особенно приятно.
- Высокая производительность: благодаря индексам и механизму хранения BSON данные читаются и пишутся очень быстро.

#### Заключение

MongoDB и Python — это мощное сочетание для разработки современных приложений. Гибкость, легкость использования и быстрая настройка делают эту базу особенно привлекательной для начинающих и опытных разработчиков.
👍1
С такими инструментами можно построить всё, от простенького блога до сложного веб-приложения.

Надеюсь, вам понравился этот небольшой экскурс в мир MongoDB. Попробуйте поиграться с ней, создайте собственные коллекции, а может, уже завтра ваш первый проект будет работать на этой базе данных. Удачи в изучении Python и до новых встреч!
👍1
Как контролировать состояние серверов и приложений с Prometheus и Python.
# Как контролировать состояние серверов и приложений с Prometheus и Python

Если вы хоть раз занимались разработкой или администрированием серверов, то наверняка знаете, насколько важно вовремя получать информацию о состоянии ваших приложений и инфраструктуры. Современный мир требует не просто мониторинга – нужно иметь доступ к гибким инструментам, которые позволят собирать метрики, анализировать их и реагировать на сбои. Одним из таких инструментов является Prometheus – мощная система мониторинга и сбора метрик. А вот чтобы сделать мониторинг еще более персонализированным и автоматизированным, в помощь приходит Python.

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

---

## Немного о Prometheus

Prometheus – это платформа для сбора, хранения и анализа метрик. Он построен по модели pull: вместо того, чтобы данные "пушились" в мониторинговую систему, сам Prometheus запрашивает их у приложения через HTTP. Приложение при этом предоставляет метрики в виде текстового формата.

Для интеграции с Prometheus в Python есть отличный модуль – prometheusclient**. С его помощью процесс экспорта метрик становится простым и элегантным.

---

## Начнем с установки

Для начала установим библиотеку prometheus
client. Сделать это можно командой:

pip install prometheus_client


После установки мы можем переходить к созданию приложения, которое экспортирует метрики для Prometheus.

---

## Базовый пример: собираем простые метрики

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

from prometheus_client import start_http_server, Counter, Summary
import time
import random

# Создаем метрики
request_count = Counter('http_requests_total', 'Total HTTP requests received')
request_latency = Summary('http_request_latency_seconds', 'Time spent processing a request')

# Функция обработки запросов
def handle_request():
# Увеличиваем счетчик запросов
request_count.inc()

# Измеряем время выполнения задачи
with request_latency.time():
time.sleep(random.uniform(0.1, 0.5))

if __name__ == '__main__':
# Запускаем HTTP сервер на порту 8000 для экспорта метрик
start_http_server(8000)
print("Prometheus metrics available at http://localhost:8000")

# Симуляция обработки запросов
while True:
handle_request()


### Как это работает?

1. Мы создаем два типа метрик:
- Counter – счетчик, который увеличивается на единицу при каждом HTTP-запросе.
- Summary – метрика, измеряющая продолжительность обработки запросов.
2. Вызываем start_http_server(8000) для запуска эндпоинта, где Prometheus сможет собирать данные.
3. В бесконечном цикле симулируем обработку запросов.

Запустив этот код, вы получите сервер, который будет отдавать метрики по адресу http://localhost:8000/metrics. Теперь, если настроить Prometheus, он сможет собирать данные с этого эндпоинта.

---

## Расширяем функционал: кастомные метрики

Иногда вам может потребоваться собирать специфичные для вашего приложения метрики. Например, вы хотите отслеживать количество ошибок или состояние определенного компонента.
👍1
Для этого можно использовать другие типы метрик:

- Gauge – измеряет текущее состояние, например, загрузку CPU или количество активных пользователей.
- Histogram – собирает данные в виде гистограммы, что удобно для анализа распределения значений.

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

from prometheus_client import Gauge

server_load = Gauge('server_load', 'Current CPU load of the server')

def simulate_server_metrics():
server_load.set(random.uniform(0, 1)) # Устанавливаем случайное значение от 0 до 1


Теперь при запросе метрик вы увидите текущую "нагрузку" сервера в процентах.

---

## Как подключить Prometheus

Чтобы Prometheus начал собирать данные, нужно добавить в его конфигурационный файл prometheus.yml следующий блок:

scrape_configs:
- job_name: 'python_app'
static_configs:
- targets: ['localhost:8000']


После этого перезапустите Prometheus. Он начнет опрашивать ваш Python-сервер каждые несколько секунд (по умолчанию раз в 15 секунд).

---

## Визуализация данных

Prometheus не предоставляет встроенный дашборд, но прекрасно интегрируется с Grafana – инструментом для визуализации данных. С помощью Grafana вы сможете создавать графики на основе метрик, собранных Prometheus.

---

## Заключение

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

Теперь вы знаете, как начать работать с Prometheus на Python. Развивайте ваши навыки и делайте мониторинг вашего приложения более умным и удобным! 🚀
👍1
Разработка игр с дополнительными эффектами физики с библиотекой pymunk.
Разработка игр с дополнительными эффектами физики с библиотекой Pymunk

Всем привет! Сегодня мы погрузимся в мир разработки игр и разберемся, как добавить физику в свои проекты с помощью замечательной библиотеки Pymunk. Если вы хотите, чтобы ваши объекты красиво падали, сталкивались или двигались так, будто на них воздействуют реальные силы, вы попали по адресу!

## Что такое Pymunk?

Pymunk — это простой и мощный Python-обёртка над физическим движком Chipmunk2D, который отлично подходит для создания физически реалистичных игр. Он интуитивно понятен даже для новичков и при этом обладает широким функционалом.

Pymunk позволяет моделировать движения объектов с учетом гравитации, трения, упругости и столкновений. С его помощью можно сделать, например, симуляцию падающей башни кубиков, веселую игру с мячиками или даже сложный механизм вроде гигантских маятников!

Теперь, когда вы знаете, что такое Pymunk, давайте начнем!

---

## Установка

Установить Pymunk очень просто:
pip install pymunk


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

---

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

Для начала попробуем создать простую симуляцию — мячик, который падает на землю.

import pymunk
import pymunk.pygame_util
import pygame
import sys

# Настройка Pygame
pygame.init()
screen = pygame.display.set_mode((600, 400))
clock = pygame.time.Clock()
draw_options = pymunk.pygame_util.DrawOptions(screen)

# Создаем пространство
space = pymunk.Space()
space.gravity = 0, 900 # Ускорение свободного падения

# Создаем пол
def create_floor():
floor_body = pymunk.Body(body_type=pymunk.Body.STATIC)
floor_shape = pymunk.Segment(floor_body, (50, 300), (550, 300), 5)
floor_shape.friction = 0.5
floor_shape.elasticity = 0.7
space.add(floor_body, floor_shape)

# Создаем мяч
def create_ball():
ball_body = pymunk.Body(mass=1, moment=10)
ball_body.position = 300, 50
ball_shape = pymunk.Circle(ball_body, 20)
ball_shape.elasticity = 0.8 # Отскок
space.add(ball_body, ball_shape)

# Создаем объекты
create_floor()
create_ball()

# Основной игровой цикл
while True:
# Проверка на выход
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()

# Очистка экрана
screen.fill((255, 255, 255))

# Отрисовка объектов
space.debug_draw(draw_options)

# Обновление симуляции
space.step(1 / 50.0)

# Обновление экрана
pygame.display.flip()
clock.tick(50)


### Что здесь происходит?
1. Создаем пространство (space): это наша физическая "вселенная", в которой находятся объекты. Мы добавляем в нее гравитацию.
2. Пол (floor): это статичная линия, которая будет служить поверхностью для столкновений.
3. Мяч (ball): это круглый объект, который взаимодействует с полом благодаря встроенной физике столкновений.
4. Игровой цикл: все стандартно — обрабатываем события, рисуем объекты, обновляем физику.

Этот простой пример можно кастомизировать: добавить больше мячей, препятствия или даже вращающиеся платформы.

---

## Дополнительные эффекты: столкновения и трение

Pymunk позволяет детально настраивать свойства объектов: упругость, трение и взаимодействие. Например, если вы добавите несколько игроков на сцену, то они будут сталкиваться с разной "жесткостью".

### Как добавить свои события при столкновениях?
В Pymunk есть система коллбеков! Вы можете задать действия, которые сработают в момент контакта объектов. Например, убавить "здоровье" персонажа или добавить эффект взрыва.

def collision_handler(arbiter, space, data):
print("Objects collided!")
return True

collision_type1 = 1
collision_type2 = 2

handler = space.add_collision_handler(collision_type1, collision_type2)
handler.begin = collision_handler


---

## Итог

Pymunk — это настоящая находка для тех, кто хочет добавить в свои игры нотку реальной физики.
Благодаря интуитивно понятному интерфейсу, изучить его проще простого. А еще веселее экспериментировать с ним, создавая собственные "песочницы" для игр!

Попробуйте применить этот инструмент в своих проектах. Например, создайте игру с падающими объектами, сбором бонусов или даже сильно замедленной физикой в духе "Матрицы". Удачи в ваших экспериментах и вдохновении!
Изучение принципов построения P2P приложений на Python.
### Изучение принципов построения P2P приложений на Python

Когда мы слышим «Peer-to-Peer» или просто P2P, обычно вспоминаются классические примеры, такие как файлообменные сети (например, старый добрый BitTorrent) или криптовалюты. Однако область применения P2P-архитектуры гораздо шире, и если до сих пор вы не пробовали реализовать её в Python, то самое время взяться за дело.

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

Давайте разберемся, как создать простейшее P2P-приложение на Python. Задача — настроить обмен сообщениями между двумя участниками (peer'ами) без посредников.

---

#### Основы P2P-приложений

Для разработки P2P-приложений нам понадобятся:
1. Сокеты (sockets) — стандартный инструмент для сетевого взаимодействия, встроенный в библиотеку Python.
2. Протокол обмена сообщениями — базовый набор правил, как peer'ы будут общаться друг с другом.
3. Механизмы обработки подключений — для поддержки нескольких участников сети.

Для примера мы напишем минимально работающий P2P-чат.

---

#### Реализация простого P2P- чата

Для простоты используем библиотеку socket для работы с подключениями и threading для поддержки одновременной отправки и получения сообщений.

import socket
import threading

# Функция для обработки входящих сообщений
def handle_incoming_messages(connection):
while True:
try:
message = connection.recv(1024).decode('utf-8')
if message:
print(f"Received: {message}")
else:
break
except:
break

# Настройка P2P-узла
def start_peer(is_host, host_ip='127.0.0.1', port=5000):
if is_host: # Узел работает как сервер
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((host_ip, port))
server_socket.listen(1)
print("Waiting for connection...")
conn, addr = server_socket.accept()
print(f"Connected by {addr}")

threading.Thread(target=handle_incoming_messages, args=(conn,)).start()
while True:
message = input("You: ").strip()
conn.send(message.encode('utf-8'))

else: # Узел работает как клиент
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((host_ip, port))
threading.Thread(target=handle_incoming_messages, args=(client_socket,)).start()
while True:
message = input("You: ").strip()
client_socket.send(message.encode('utf-8'))

# Выбор режима работы
mode = input("Run as host? (yes/no): ").strip().lower()
is_host = mode == 'yes'
host_ip = input("Enter host IP (default 127.0.0.1): ").strip() or '127.0.0.1'
start_peer(is_host, host_ip)


---

#### Разбор кода

1. Мы создаем двух участников (peer'ов) сети: один действует как сервер (хост), другой — как клиент.
2. Сервер ожидает подключений, а клиент инициирует их.
3. Используем многопоточность через библиотеку threading, чтобы одновременно отправлять и получать сообщения.
4. Каждый peer может принимать и отправлять текстовые сообщения другому узлу.

---

#### Что дальше?

Хоть этот пример работает, он довольно примитивен:
- У него нет шифрования (а в P2P безопасности уделяют особое внимание).
- Подключиться могут только два участника. Для расширения функционала, например, добавления поддержки нескольких людей в одной сети, можно использовать библиотеку asyncio, которая упростит обработку множества подключений.

Полные реализации P2P-приложений могут включать в себя:
- Протоколы для поиска узлов в сети.
- Механизмы передачи файлов или больших объемов данных.
- Шифрование и аутентификацию.

Библиотеки, которые помогут упростить разработку сложных P2P-приложений:
1.
👍1
asyncio — для асинхронной обработки сетевых событий.
2. cryptography — для добавления шифрования данных.
3. libp2p — готовый фреймворк для создания P2P-сетей (хотя все еще находится в процессе активной разработки).

---

#### Итог

Создание P2P-приложений на Python — это отличный способ погрузиться в мир сетевого программирования. Даже если вы создадите простейший чат, как в приведенном примере, вы почувствуете всю магию прямого взаимодействия устройств. Кто знает, может, однажды вы разработаете распределенную сеть, которая перевернет мир технологий? 🚀
Создание и управление потоками работы с Celery.
### Создание и управление потоками работы с Celery

Вы когда-нибудь задумывались о том, как выполняются долгие фоновые задачи, пока основной код программы продолжает свою работу, словно ничего и не произошло? Если ваша программа генерирует отчеты, обрабатывает тяжелые данные или отправляет сотни писем, вам точно не обойтись без системы управления задачами. И вот тут на сцену выходит Celery — мощный инструмент, который поможет сделать вашу жизнь проще и ваш код быстрее.

Сегодня разберемся, как начать использовать Celery, как он устроен и почему это один из самых популярных инструментов для работы с асинхронными задачами.

---

### Знакомство с Celery

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

Как Celery работает?
1. Ваша программа создает задачу.
2. Задача отправляется в брокер (обычно используется Redis или RabbitMQ).
3. Рабочий процесс (worker) берется за выполнение задачи.
4. Как только задача завершена, результат может быть сохранен в бэкенд-хранилище для будущего использования.

---

### Установка и настройка

Для начала установим все необходимые компоненты. Обязательный пакет Celery и брокер сообщений (возьмем Redis).

pip install celery redis


Далее создадим базовый файл конфигурации tasks.py. Вот пример простой настройки Celery:

from celery import Celery

app = Celery('my_celery_app', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')

@app.task
def add_numbers(a, b):
return a + b


Здесь:
- 'myceleryapp' — имя приложения Celery.
- broker — адрес Redis, который отвечает за управление очередями задач.
- backend — хранилище для результатов выполнения задач.

---

### Запуск рабочего процесса

Чтобы начать выполнять фоновые задачи, нужно запустить worker — процесс, который слушает очередь сообщений и выполняет задачи. Запустим его следующей командой:

celery -A tasks worker --loglevel=info


Теперь worker готов принять задачи.

---

### Создание задач

Допустим, вы хотите сложить два числа. Вместо выполнения задачи в основном потоке ваш код может отправить её в Celery. Так процесс станет асинхронным.

from tasks import add_numbers

result = add_numbers.delay(7, 8) # .delay() отправляет задачу в Celery
print(f'Task ID: {result.id}')


Метод .delay() ставит задачу в очередь, и Celery выполняет её в фоне. Ваш основной код продолжит выполнение, а результат задачи сохранится в backend.

---

### Получение результатов

Допустим, задача завершилась, и результат хранится в Redis. Чтобы его забрать, используйте метод .get():

if result.ready():  # Проверяем, завершена ли задача
print('The result is:', result.get())
else:
print('Task is still in progress...')


Метод .ready() позволяет понять, завершена задача или ещё выполняется.

---

### Расширенные функции: периодические задачи

Celery поддерживает выполнение задач не только «по запросу», но и через определенные промежутки времени. Для этого используется дополнительный модуль celery-beat.

Установим его:
pip install celery[redis] django-celery-beat


С помощью celery-beat внутри задачи можно, например:
1. Генерировать еженедельные отчеты.
2. Напоминать пользователям об истечении сроков.
3. Чистить базу данных.

---

### Отладка и мониторинг

Для упрощения мониторинга любая очередь требует визуализации. Celery интегрируется с веб-интерфейсами, такими как Flower. Установим его:

pip install flower


Запускаем мониторинг:
celery -A tasks flower


Теперь на http://localhost:5555 вы сможете отслеживать состояние задач, видеть их длительность и распределение нагрузки.

---

### Ловушки и ошибки новичков

1.
👍1
Брокер обязателен. Без настройки Redis или RabbitMQ ваш Celery даже не начнет работать — он нуждается в центральной системе, чтобы управлять очередями.
2. Медленные задачи. Если задача выполняется слишком долго, worker может «зависнуть». Делите задачи на меньшие части.
3. Неправильный backend. Хранение слишком больших результатов задач в Redis — плохая идея. Для таких сценариев лучше подойдет база данных.

---

### Итог

Celery станет мощным союзником для обработки фоновых задач в Python. Используя его, вы не только ускорите работу своих приложений, но и сделаете их более масштабируемыми. Если вы хотите разрабатывать современные приложения, умение работать с Celery — обязательный навык. Попробуйте, и вы наверняка влюбитесь в простоту и возможности этого инструмента!
👍2
Как написать бота для Telegram с использованием библиотеки Telethon
### Как написать бота для Telegram с использованием библиотеки Telethon

В мире Telegram-ботов царит невероятное разнообразие — от помощников в планировании задач до интерактивных игр и аналитических инструментов. Вы хотите создать своего собственного, но вас пугает сложность? Не переживайте! С библиотекой Telethon создание бота становится настолько простым и увлекательным процессом, что вам захочется продолжать и дальше экспериментировать. Сегодня я покажу вам, как это сделать.

---

#### Что такое Telethon?

Telethon — это асинхронная библиотека для работы с API Telegram на Python. Она позволяет создавать клиентов, которые могут отправлять сообщения, читать чаты, управлять файлами и выполнять многие другие задачи. В отличие от Telegram Bot API, Telethon работает с пользовательскими аккаунтами и предоставляет больше возможностей.

---

### Шаг 1. Установка библиотеки
Сначала давайте установим Telethon. Это делается очень просто с помощью команды:

pip install telethon


Убедитесь, что у вас стоит версия Python не ниже 3.7, чтобы Telethon работал без проблем.

---

### Шаг 2. Получение API-ключей
Для работы с Telegram-API вам нужно получить пару ключей: APIID** и **APIHASH. Вот как это сделать:

1. Зайдите на сайт my.telegram.org.
2. Войдите под своим аккаунтом Telegram.
3. Перейдите в раздел "API Development Tools".
4. Создайте новое приложение и получите нужные ключи.

Сохраните их в надёжном месте!

---

### Шаг 3. Минимальный бот на Telethon

Теперь давайте создадим простого бота, который будет отвечать на ваши сообщения. Для этого создадим файл bot.py и начнём с настройки окружения:

from telethon import TelegramClient, events

# Ваши API_ID и API_HASH
api_id = 123456 # Замените на ваш API_ID
api_hash = 'your_api_hash' # Замените на ваш API_HASH

# Создаём клиента
client = TelegramClient('bot_session', api_id, api_hash)

# Отлавливаем входящие сообщения
@client.on(events.NewMessage)
async def handler(event):
sender = await event.get_sender()
print(f"Incoming from {sender.username}: {event.text}")

# Ответ бота
await event.reply('Hello! This is a simple bot powered by Telethon!')

# Запуск клиента
print("Bot is running...")
client.start()
client.run_until_disconnected()


---

### Разберём код

1. Инициализация клиента: Мы создаём объект TelegramClient, передавая ему сессионное имя, api_id и api_hash. Это позволяет клиенту подключиться к Telegram.

2. Обработка сообщений: Используя декоратор @client.on, мы говорим Telethon, что хотим обрабатывать новые сообщения (events.NewMessage).

3. Ответ бота: Метод event.reply отправляет сообщение в тот же чат, откуда пришёл запрос.

4. Запуск бота: Метод client.start автоматически проверяет ключи и запускает сессию. А client.run_until_disconnected(), как следует из названия, держит бота "включённым".

---

### Шаг 4. Дополняем функционал

Теперь представим, что наш бот должен сообщать текущее время, если пользователь напишет команду /time. Это легко сделать, добавив небольшую проверку:

import datetime

@client.on(events.NewMessage)
async def handler(event):
if event.text == '/time':
now = datetime.datetime.now().strftime('%H:%M:%S')
await event.reply(f'Current time: {now}')
else:
await event.reply('Unknown command. Try /time!')


Теперь бот будет умнее и полезнее! Вы могли заметить, насколько гибко библиотека обрабатывает входящие события. Это позволяет реализовать любые сценарии.

---

### Шаг 5. Запуск бота

Чтобы запустить бота, достаточно набрать в терминале:
python bot.py


Перейдите в Telegram и отправьте себе сообщение.
👍1
Для тестирования можно написать /time и проверить, как бот реагирует.

---

### Чем Telethon лучше Bot API?

С помощью Telethon вы можете:
- Автоматизировать действия от лица обычного аккаунта.
- Управлять вашим личным чатом, пересылать сообщения из одного канала в другой.
- Загружать или скачивать файлы и медиаконтент.
- Получать полные данные о чатах и их участниках.

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

---

### Заключение

Telethon — это мощный инструмент для разработки Telegram-ботов и клиентов. Его гибкость и обширные возможности открывают перед вами невероятные перспективы. Начав с простого, вы сможете легко изучить более сложные сценарии: от взаимодействия с базами данных до интеграции с внешними API.

Попробуйте создать своего первого Telegram-бота уже сегодня. Уверен, вы получите массу удовольствия! 🚀
👍1
Основы создания и настройки виртуальных машин на Python
# Основы создания и настройки виртуальных машин на Python

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

Вы спросите: «А зачем мне это вообще нужно?». Представьте себе лабораторию для тестирования, возможность безопасно запускать код или воспроизводить настройки серверов. Всё это можно делать с помощью Python и пары полезных библиотек. В этой статье я покажу, как с минимальными усилиями освоить эти инструменты.

### Модуль libvirt — ваш мост в мир виртуальных машин

Для управления виртуальными машинами на Python мы будем использовать модуль libvirt. Эта библиотека работает с различными виртуализаторами, такими как KVM, QEMU, VirtualBox и другими. Но будьте осторожны: чтобы использовать libvirt, в системе должен быть установлен соответствующий сервер, например, libvirtd для Linux.

Установить библиотеку можно стандартным образом:

pip install libvirt-python


Теперь погнали к практике!

### Подключение к гипервизору

Для управления виртуальными машинами сначала нужно подключиться к гипервизору. Вот как это делается:

import libvirt

def connect_to_hypervisor():
try:
conn = libvirt.open("qemu:///system") # Подключение к локальному гипервизору (QEMU/KVM)
if conn is None:
print("Failed to open connection to the hypervisor")
return None
print("Connection to hypervisor established")
return conn
except libvirt.libvirtError as e:
print(f"Error: {e}")
return None

connection = connect_to_hypervisor()


Здесь мы используем URI qemu:///system, но вы можете заменить его на нужный вам гипервизор. Если всё настроено правильно, вы получите активное соединение.

### Список виртуальных машин

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

def list_virtual_machines(conn):
domains = conn.listAllDomains()
if len(domains) == 0:
print("No virtual machines found")
return
for domain in domains:
print(f"VM Name: {domain.name()}, Active: {'Yes' if domain.isActive() else 'No'}")

if connection:
list_virtual_machines(connection)


Этот код покажет имена всех виртуальных машин и их текущий статус (активны они или нет).

### Создание виртуальной машины

Виртуальные машины создаются на основе XML-дескрипторов, описывающих конфигурацию: CPU, RAM, диски и так далее. Вот пример создания самой простой VM:

vm_xml = """
<domain type='kvm'>
<name>test_vm</name>
<memory unit='KiB'>1048576</memory> <!-- 1GB RAM -->
<vcpu placement='static'>1</vcpu>
<os>
<type arch='x86_64' machine='pc-i440fx-focal'>hvm</type>
</os>
<devices>
<disk type='file' device='disk'>
<driver name='qemu' type='qcow2'/>
<source file='/var/lib/libvirt/images/test_vm.qcow2'/>
<target dev='vda' bus='virtio'/>
</disk>
<interface type='network'>
<source network='default'/>
</interface>
</devices>
</domain>
"""

def create_vm(conn, xml_description):
try:
conn.createXML(xml_description, 0)
print("Virtual machine created successfully")
except libvirt.libvirtError as e:
print(f"Failed to create VM: {e}")

if connection:
create_vm(connection, vm_xml)


Здесь указывается конфигурация виртуальной машины: 1 ГБ памяти, 1 CPU, диск и сеть. Вам понадобится подготовить образ диска (например, в формате qcow2) заранее.

### Управление виртуальными машинами

Запустить или остановить виртуальную машину?
Всё просто:

def start_vm(conn, vm_name):
domain = conn.lookupByName(vm_name)
if domain.isActive():
print(f"VM '{vm_name}' is already running")
else:
domain.create()
print(f"VM '{vm_name}' started")

def stop_vm(conn, vm_name):
domain = conn.lookupByName(vm_name)
if domain.isActive():
domain.destroy()
print(f"VM '{vm_name}' stopped")
else:
print(f"VM '{vm_name}' is not running")

if connection:
start_vm(connection, "test_vm")
stop_vm(connection, "test_vm")


Вот и всё! Управление виртуальными машинами стало как никогда доступным.

### Заключение

Создание и управление виртуальными машинами с помощью Python может показаться сложной задачей, но с модулем libvirt это становится вполне выполнимым даже для новичка. Погружаясь в эту тему, вы обучаетесь не только программированию, но и основам администрирования, что делает вас ещё более универсальным специалистом.

Так что вперёд! Экспериментируйте, создавайте свои виртуальные миры, запускайте тестовые среды и совершенствуйте свои навыки Python!
🔥1