Для вставки гиперссылки в документ Word с использованием библиотеки python-docx, вам нужно создать гиперссылку вручную, так как библиотека python-docx в настоящее время не имеет встроенной поддержки для добавления гиперссылок напрямую. Однако, вы можете обойти это ограничение, добавив гиперссылку в виде текста. Вот как это можно сделать:

from docx import Document
from docx.shared import Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.oxml import OxmlElement
from docx.oxml.ns import qn

# Функция для добавления заголовка
def add_heading(document, text, level=1):
    heading = document.add_heading(text, level=level)
    heading.alignment = WD_ALIGN_PARAGRAPH.CENTER

# Функция для добавления параграфа с обычным текстом
def add_paragraph(document, text):
    paragraph = document.add_paragraph(text)
    for run in paragraph.runs:
        run.font.size = Pt(12)

# Функция для добавления гиперссылки
def add_hyperlink(paragraph, url, text, color='0000FF', underline=True):
    # Создание элемента гиперссылки
    part = paragraph.part
    r_id = part.relate_to(url, qn('r:hyperlink'), is_external=True)

    hyperlink = OxmlElement('w:hyperlink')
    hyperlink.set(qn('r:id'), r_id)

    # Создание стиля для текста гиперссылки
    r = OxmlElement('w:r')
    rPr = OxmlElement('w:rPr')

    # Установка цвета
    c = OxmlElement('w:color')
    c.set(qn('w:val'), color)
    rPr.append(c)

    # Установка подчеркивания
    if underline:
        u = OxmlElement('w:u')
        u.set(qn('w:val'), 'single')
        rPr.append(u)

    r.append(rPr)

    # Добавление текста в гиперссылку
    t = OxmlElement('w:t')
    t.text = text
    r.append(t)

    hyperlink.append(r)
    paragraph._p.append(hyperlink)

# Создаем документ
doc = Document()

# Добавляем заголовок
add_heading(doc, 'Резюме', level=0)

# Личная информация
add_heading(doc, 'Личная информация', level=1)
add_paragraph(doc, 'Имя: Иван Иванов')
add_paragraph(doc, 'Email: ivanov@example.com')
add_paragraph(doc, 'Телефон: +7 123 456 7890')

# Образование
add_heading(doc, 'Образование', level=1)
p = doc.add_paragraph()
p.add_run('Курсы KODDUU - ')
add_hyperlink(p, 'https://stepik.org/a/185238', 'Информация о курсе')

# Навыки
add_heading(doc, 'Навыки', level=1)
add_paragraph(doc, 'Языки программирования: Python')
add_paragraph(doc, 'Фреймворки: Django, Flask')
add_paragraph(doc, 'Базы данных: MySQL, PostgreSQL')
add_paragraph(doc, 'Инструменты: Git, Docker')

# Опыт работы
add_heading(doc, 'Опыт работы', level=1)
add_paragraph(doc, 'Junior Python Developer, ООО "Разработка", июнь 2022 - настоящее время')
add_paragraph(doc, 'Описание деятельности и достижений...')

# Сохраняем документ
doc.save('resume_with_hyperlink.docx')

Этот способ может быть не идеален, но на данный момент это одно из возможных решений для добавления гиперссылок в документы Word с использованием python-docx.

Подпишись 👉🏻 @KodduuPython 🤖

Чтобы написать скрипт, который парсит адреса кошельков в сети TRON, вам понадобится использовать API, предоставляемый TRON или сторонними сервисами, если таковые существуют. TRON — это блокчейн-платформа, которая предоставляет свой собственный публичный API для доступа к данным сети.

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

import requests
import json

# URL для запросов к API TRON
API_URL = "https://api.trongrid.io"

# Функция для получения транзакций по адресу блока
def get_transactions_by_block(block_id):
    endpoint = f"{API_URL}/v1/blocks/{block_id}/transactions"
    response = requests.get(endpoint)
    if response.status_code == 200:
        return response.json()['data']
    else:
        print("Error:", response.status_code, response.text)
        return None

# Замените block_id на актуальный номер блока
block_id = "ВАШ_НОМЕР_БЛОКА"

# Получаем транзакции для указанного блока
transactions = get_transactions_by_block(block_id)
if transactions:
    wallet_addresses = set()
    for tx in transactions:
        # Извлекаем адреса отправителя и получателя из транзакции
        if 'raw_data' in tx and 'contract' in tx['raw_data']:
            for contract in tx['raw_data']['contract']:
                # Проверяем тип контракта (например, TransferContract для TRX)
                if contract['type'] == "TransferContract":
                    wallet_addresses.add(contract['parameter']['value']['owner_address'])
                    wallet_addresses.add(contract['parameter']['value']['to_address'])
    
    print("Найденные адреса кошельков:")
    for address in wallet_addresses:
        print(address)
else:
    print("Не удалось получить транзакции для блока:", block_id)

Важные моменты:

Замените "ВАШ_НОМЕР_БЛОКА" на актуальный номер блока, информацию по которому вы хотите получить. Проверьте, что тип контракта соответствует тому, что вы ищете (например, 'TransferContract' для перевода TRX). Учтите, что API может измениться со временем, и вам потребуется обновить код в соответствии с новой документацией API TRON.

Вам может потребоваться преобразовать адреса из Base58 или другого формата, используемого в TRON, в читаемый вид, если API возвращает их в закодированном виде.

Помните, что при работе с блокчейном и кошельками важно соблюдать конфиденциальность и не нарушать чьи-либо права на приватность.

Подпишись 👉🏻 @KodduuPython 🤖

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

### Шаг 1: Выбор торговой платформы и изучение её API
Выберите биржу или торговую платформу, которая предоставляет API для автоматической торговли. Примеры популярных платформ включают Binance, Alpaca, Interactive Brokers и другие. Изучите документацию API для понимания возможностей, ограничений и требований безопасности.

### Шаг 2: Установка необходимых библиотек
Установите необходимые Python-библиотеки, которые могут понадобиться для работы с API, анализа данных и реализации торговой логики. Примеры таких библиотек:

pip install requests pandas numpy

Для некоторых платформ могут потребоваться специфические библиотеки или SDK.

### Шаг 3: Получение данных о рынке
Используйте API платформы для получения данных о рынке, таких как цены активов, объем торгов и другие.

import requests

# Пример запроса к API (зависит от выбранной платформы)
response = requests.get('API_URL')
market_data = response.json()

### Шаг 4: Разработка торговой стратегии
Разработайте стратегию, на основе которой бот будет принимать решения о покупке и продаже. Это может быть простая стратегия на основе технических индикаторов или более сложная, использующая методы машинного обучения.

def trading_strategy(market_data):
    # Ваша логика торговли
    pass

### Шаг 5: Реализация алгоритма торговли
Интегрируйте вашу торговую стратегию с API для выполнения сделок.

def execute_trade(decision, amount):
    # Код для отправки торговых приказов через API
    pass

### Шаг 6: Тестирование
Протестируйте вашего бота в безопасной среде, используя исторические данные или симулятор торговли (если доступен).

### Шаг 7: Запуск и мониторинг
Запустите бота на реальном счете с ограниченным капиталом и тщательно отслеживайте его работу для корректировки стратегии и исправления ошибок.

### Важные замечания:
- Безопасность: Обращайте внимание на безопасность, особенно при работе с API-ключами и торговле на реальных счетах.
- Комиссии: Учитывайте комиссии при разработке стратегии.
- Риски: Торговля на финансовых рынках связана с рисками. Не рискуйте средствами, потерю которых вы не можете себе позволить.
- Юридические аспекты: Убедитесь, что ваша деятельность соответствует законодатель

Подпишись 👉🏻 @KodduuPython 🤖

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

### Предварительные требования
- Убедитесь, что у вас есть аккаунт на Binance и получены API-ключ и секретный ключ.
- Установите необходимую библиотеку для работы с Binance API:

  pip install python-binance
  

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

from binance.client import Client
import time

api_key = 'YOUR_API_KEY'
api_secret = 'YOUR_API_SECRET'

# Инициализация клиента Binance
client = Client(api_key, api_secret)

# Настройки торговли
symbol = 'BTCUSDT'  # Пара, с которой мы будем работать
amount = 0.001       # Количество BTC для покупки/продажи

def get_price():
    """ Получить последнюю цену для пары """
    ticker = client.get_symbol_ticker(symbol=symbol)
    return float(ticker['price'])

def make_trade():
    """ Принять решение о покупке/продаже """
    price = get_price()
    print(f"Текущая цена {symbol}: {price}")

    # Пример торговой стратегии: покупка, если цена ниже определенной суммы
    if price < 10000:
        # Совершение покупки
        order = client.order_market_buy(symbol=symbol, quantity=amount)
        print(order)
    elif price > 15000:
        # Совершение продажи
        order = client.order_market_sell(symbol=symbol, quantity=amount)
        print(order)

# Основной цикл торгового бота
while True:
    try:
        make_trade()
        time.sleep(60)  # Пауза перед следующей проверкой
    except Exception as e:
        print(f"Произошла ошибка: {e}")

### Важные замечания:
1. Тестирование: Прежде чем запускать бота на реальном счете, тестируйте его на тестовом счете Binance.
2. Осторожность: Торговля на рынке сопряжена с рисками. Не рискуйте средствами, которые вы не готовы потерять.
3. Ограничения API: Обратите внимание на ограничения и правила использования API Binance, чтобы избежать блокировки вашего аккаунта.
4. Обработка ошибок: В примере представлена только базовая обработка ошибок. Рекомендуется разработать более полноценную систему обработки ошибок для устойчивости вашего бота к различным исключительным ситуациям.

5. Безопасность: Храните API-ключ и секретный ключ в безопасном месте и никогда не делитесь ими. Рассмотрите возможность использования переменных окружения для их хранения.

6. Мониторинг: Регулярно мониторьте работу бота и рынок, чтобы убедиться, что всё работает, как задумано, и нет неожиданных ситуаций.

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

8. Тестирование стратегии: Прежде чем использовать стратегию в реальной торговле, тщательно протестируйте её на исторических данных.

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

Подпишись 👉🏻 @KodduuPython 🤖

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

import re

# Путь к файлу логов
log_file_path = 'path_to_your_log_file.log'

# Регулярное выражение для поиска e-mail
email_pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')

# Список найденных e-mail
emails = []

# Открытие файла логов и поиск e-mail
with open(log_file_path, 'r') as file:
    for line in file:
        matches = email_pattern.findall(line)
        emails.extend(matches)

# Удаление возможных дубликатов
unique_emails = list(set(emails))

# Вывод списка найденных e-mail
for email in unique_emails:
    print(email)

В этом коде:

— Используется модуль re для работы с регулярными выражениями.
— Задается путь к файлу логов.
— Создается регулярное выражение для поиска адресов электронной почты.
— Открывается файл логов и построчно анализируется на наличие адресов электронной почты.
— Найденные адреса электронной почты сохраняются в список.
— Удаляются дубликаты адресов, если они есть.
— Выводятся на экран уникальные адреса электронной почты.

Убедитесь, что путь к файлу логов (log_file_path) указан правильно. Регулярное выражение, используемое здесь, является базовым и может потребовать настройки в зависимости от формата адресов электронной почты в ваших лог-файлах.

Подпишись 👉🏻 @KodduuPython 🤖

Чтобы отправить электронные письма по списку адресов и сохранить список успешно отправленных адресов, можно использовать библиотеку smtplib для отправки писем и email.mime.text для создания тела письма. Ниже пример кода на Python, который делает это:

import smtplib
from email.mime.text import MIMEText

# Список адресов электронной почты для отправки
email_list = ['example1@example.com', 'example2@example.com']

# Информация для входа в почтовый сервер
smtp_server = 'smtp.example.com'
smtp_port = 587
smtp_user = 'your_username@example.com'
smtp_password = 'your_password'

# Создание сообщения
subject = 'Тема вашего письма'
body = 'Текст вашего письма.'
message = MIMEText(body)
message['Subject'] = subject
message['From'] = smtp_user
message['To'] = ', '.join(email_list)

# Отправка писем и сохранение успешно отправленных адресов
sent_emails = []

# Подключение к SMTP серверу
with smtplib.SMTP(smtp_server, smtp_port) as server:
    try:
        server.starttls()  # Начало зашифрованного соединения
        server.login(smtp_user, smtp_password)  # Вход на почтовый сервер

        # Отправка письма каждому адресату
        for email in email_list:
            try:
                server.sendmail(smtp_user, email, message.as_string())
                print(f"Письмо успешно отправлено на {email}")
                sent_emails.append(email)
            except Exception as e:
                print(f"Ошибка при отправке письма на {email}: {e}")
                
    except Exception as e:
        print(f"Ошибка подключения к SMTP серверу: {e}")

# Сохранение списка успешно отправленных адресов
with open('sent_emails.txt', 'w') as file:
    for email in sent_emails:
        file.write(email + '\n')

print("Список успешно отправленных адресов сохранен в файле 'sent_emails.txt'.")

В этом коде:

— Настройте список email_list с адресами электронной почты, на которые вы хотите отправить письма.
— Заполните данные для входа на почтовый сервер (smtp_server, smtp_port, smtp_user, smtp_password).
— Создайте тему и тело сообщения.
— В цикле отправляйте письма каждому адресату, записывая успешно отправленные адреса в sent_emails.
— Сохраните список успешно отправленных адресов в файл sent_emails.txt.

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

Подпишись 👉🏻 @KodduuPython 🤖

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

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

Установите Pygame, если у вас еще нет:

pip install pygame

Пример кода эмулятора траффика:

import pygame
import random
import sys

# Инициализация Pygame
pygame.init()

# Настройки экрана
SCREEN_WIDTH, SCREEN_HEIGHT = 800, 600
BACKGROUND_COLOR = (30, 30, 30)
ROAD_COLOR = (50, 50, 50)
CAR_COLOR = (200, 200, 0)
FPS = 60

# Настройки дороги
ROAD_WIDTH = 100
HORIZONTAL_ROAD_Y = (SCREEN_HEIGHT // 2) - (ROAD_WIDTH // 2)
VERTICAL_ROAD_X = (SCREEN_WIDTH // 2) - (ROAD_WIDTH // 2)

# Настройки машины
CAR_SIZE = (40, 20)
CAR_SPEED = 5

# Генератор случайной позиции для машин
def get_random_position():
    direction = random.choice(['left', 'right', 'up', 'down'])
    if direction == 'left':
        return (-CAR_SIZE[0], random.randint(HORIZONTAL_ROAD_Y, HORIZONTAL_ROAD_Y + ROAD_WIDTH - CAR_SIZE[1])), (CAR_SPEED, 0)
    elif direction == 'right':
        return (SCREEN_WIDTH, random.randint(HORIZONTAL_ROAD_Y, HORIZONTAL_ROAD_Y + ROAD_WIDTH - CAR_SIZE[1])), (-CAR_SPEED, 0)
    elif direction == 'up':
        return (random.randint(VERTICAL_ROAD_X, VERTICAL_ROAD_X + ROAD_WIDTH - CAR_SIZE[0]), -CAR_SIZE[1]), (0, CAR_SPEED)
    else: # down
        return (random.randint(VERTICAL_ROAD_X, VERTICAL_ROAD_X + ROAD_WIDTH - CAR_SIZE[0]), SCREEN_HEIGHT), (0, -CAR_SPEED)

# Инициализация экрана и часов
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Перекресток")
clock = pygame.time.Clock()

# Список машин
cars = []

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

    # Добавление новой машины случайным образом
    if random.randint(1, 60) == 1:
        position, velocity = get_random_position()
        cars.append([position, velocity])

    # Обновление экрана
    screen.fill(BACKGROUND_COLOR)
    pygame.draw.rect(screen, ROAD_COLOR, (VERTICAL_ROAD_X, 0, ROAD_WIDTH, SCREEN_HEIGHT))
    pygame.draw.rect(screen, ROAD_COLOR, (0, HORIZONTAL_ROAD_Y, SCREEN_WIDTH, ROAD_WIDTH))

    # Обновление и отрисовка машин
    for car in cars:
        car[0] = car[0][0] + car[1][0], car[0][1] + car[1][1]  # Обновление позиции
        pygame.draw.rect(screen, CAR_COLOR, (*car[0], *CAR_SIZE))  # Отрисовка машины

    # Удаление машин, выехавших за пределы экрана
    cars = [car for car in cars if -CAR_SIZE[0] <= car[0][0] <= SCREEN_WIDTH and -CAR_SIZE[1] <= car[0][1] <= SCREEN_HEIGHT]

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

Подпишись 👉🏻 @KodduuPython 🤖

Код для получения погоды:

import pyowm # библиотека для получения погоды
from PIL import Image, ImageDraw # библиотека для работы с изображениями
import random # стандартная библиотека
import pyttsx3 # библиотека для синтеза речи

# Получение данных о погоде
owm = pyowm.OWM('your_api_key')  
observation = owm.weather_at_place('Moscow,RU')
w = observation.get_weather()
temperature = w.get_temperature('celsius')['temp']

# Рисуем солнце или облака в зависимости от погоды 
img = Image.new('RGBA', (300, 300), 'white')
draw = ImageDraw.Draw(img)
if w.is_clear():
  draw.ellipse((100, 100, 200, 200), fill='yellow') 
else:  
  draw.rectangle((100, 100, 200, 200), fill='grey')

# Читаем текст с погодой
text = f'Сейчас в Москве {temperature} градусов'
speaker = pyttsx3.init()  
speaker.say(text)
speaker.runAndWait()

# Сохраняем картинку
img.save('weather.png')

Данный код демонстрирует получение данных о погоде, рисование изображения, синтез речи и работу с нестандартными библиотеками PyOWM, PIL, pyttsx3.

Подпишись 👉🏻 @KodduuPython 🤖

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

Установите библиотеку faker, если у вас её еще нет:

pip install faker

Теперь, используя faker, создадим скрипт, который генерирует случайные профили людей:

from faker import Faker
fake = Faker()

def generate_profiles(num_profiles):
    profiles = []
    for _ in range(num_profiles):
        profile = {
            "name": fake.name(),
            "address": fake.address(),
            "email": fake.email(),
            "birth_date": fake.date_of_birth(tzinfo=None, minimum_age=18, maximum_age=85),
            "company": fake.company(),
            "text": fake.text()
        }
        profiles.append(profile)
    return profiles

if __name__ == "__main__":
    num_profiles_to_generate = 5  # Вы можете изменить это число на то, которое вам нужно
    profiles = generate_profiles(num_profiles_to_generate)

    for i, profile in enumerate(profiles, start=1):
        print(f"Profile {i}:")
        print(f"Name: {profile['name']}")
        print(f"Address: {profile['address']}")
        print(f"Email: {profile['email']}")
        print(f"Birth Date: {profile['birth_date']}")
        print(f"Company: {profile['company']}")
        print(f"Text: {profile['text']}\n")

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

Запустите этот скрипт, и он выведет несколько случайно сгенерированных профилей в консоль.

Подпишись 👉🏻 @KodduuPython 🤖

Код для управления GPIO на Raspberry Pi:

from gpiozero import LEDBoard
from signal import pause
import time

# Библиотека для управления GPIO на RPi
ledboard = LEDBoard(2,3,4,5) 

# Включаем все светодиоды
ledboard.on()
time.sleep(1) 

# Моргаем светодиодами
for i in range(5):
  ledboard.off()
  time.sleep(0.2)
  ledboard.on()
  time.sleep(0.2)

# Гасим светодиоды поочередно  
for led in ledboard.leds:
  led.off()
  time.sleep(0.5)

# Ждем нажатия клавиши 
print("Нажмите Enter для выхода")
pause()

В этом примере используется библиотека gpiozero для управления GPIO на Raspberry Pi. Она позволяет включать/выключать светодиоды, моргать ими и управлять поочередно. Это демонстрирует управление выводами через Python.

Подпишись 👉🏻 @KodduuPython 🤖

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

Установите библиотеку plumbum, если у вас её еще нет:

pip install plumbum

Теперь создадим небольшой скрипт, который использует plumbum для поиска и вывода всех файлов Python (с расширением .py) в текущем каталоге:

from plumbum.cmd import ls, grep
from plumbum import local

def find_python_files():
    # Получаем текущий путь
    with local.cwd('.'):
        # Выполняем команду ls для перечисления файлов и grep для фильтрации по расширению .py
        python_files = ls | grep["\.py$"]
        
        # Выводим результаты
        for file in python_files():
            print(file)

if __name__ == "__main__":
    find_python_files()

Этот скрипт использует команды ls и grep в Unix-подобных системах для поиска файлов с расширением .py. plumbum позволяет передавать вывод одной команды в другую, аналогично тому, как это делается в оболочке с помощью оператора |.

Запустите этот скрипт в каталоге, где у вас есть файлы Python, и он выведет список этих файлов.

Обратите внимание, что этот код может не работать в Windows из-за отсутствия команд ls и grep, если только у вас не установлены их аналоги или вы не используете подсистему Windows для Linux (WSL).

Подпишись 👉🏻 @KodduuPython 🤖

Вычисление признаков аудио файла:

from python_speech_features import mfcc
import soundfile as sf

# Загружаем аудио файл
data, samplerate = sf.read('audio.wav') 

# Вычисляем MFCC признаки
features = mfcc(data, samplerate) 

# Сохраняем признаки в файл
sf.write('mfcc.csv', features, samplerate, format='csv')

В этом коде используется библиотека python_speech_features для расчета MFCC (Mel-частотные кепстральные коэффициенты) признаков из аудио файла.

MFCC широко используются в распознавании речи и классификации аудио. Эта библиотека позволяет легко извлекать такие признаки на Python.

Также задействована библиотека soundfile для загрузки/сохранения аудио.

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

Подпишись 👉🏻 @KodduuPython 🤖

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

Установите scapy, если у вас её еще нет:

pip install scapy

Теперь создадим скрипт, который будет отправлять простой ARP-запрос (Address Resolution Protocol) в сеть для определения MAC-адреса устройства по его IP-адресу:

from scapy.all import ARP, Ether, srp

def arp_request(target_ip):
    # Создание Ethernet-фрейма (с MAC-адресом назначения как broadcast)
    ether_layer = Ether(dst="ff:ff:ff:ff:ff:ff")
    
    # Создание ARP-запроса (кто имеет target_ip? Скажи <наш IP>)
    arp_layer = ARP(pdst=target_ip)
    
    # Соединение слоев
    packet = ether_layer / arp_layer
    
    # Отправка пакета и получение ответов
    result = srp(packet, timeout=2, verbose=False)[0]

    # Вывод результатов
    for sent, received in result:
        print(f"IP-адрес: {received.psrc} MAC-адрес: {received.hwsrc}")

if __name__ == "__main__":
    target_ip = "192.168.1.1"  # Замените на IP-адрес в вашей сети
    arp_request(target_ip)

Этот скрипт отправляет ARP-запрос в локальную сеть для получения MAC-адреса устройства с заданным IP-адресом. Обратите внимание, что для отправки таких запросов может потребоваться права администратора.

Давайте теперь сделаем что-то ещё более интересное: сканирование локальной сети на наличие активных устройств. Мы модифицируем предыдущую функцию, чтобы она сканировала диапазон IP-адресов:

def arp_scan(network):
    # Создание Ethernet-фрейма
    ether_layer = Ether(dst="ff:ff:ff:ff:ff:ff")
    arp_layer = ARP(pdst=network)
    packet = ether_layer / arp_layer
    
    # Отправка пакета и получение ответов
    result = srp(packet, timeout=2, verbose=False)[0]

    # Вывод результатов
    clients = []
    for sent, received in result:
        clients.append({'ip': received.psrc, 'mac': received.hwsrc})
    
    print("Доступные устройства в сети:")
    print("IP" + " " * 18+"MAC")
    for client in clients:
        print("{:16}    {}".format(client['ip'], client['mac']))

if __name__ == "__main__":
    # Замените на адрес вашей локальной сети/диапазон, например '192.168.1.1/24'
    network = '192.168.1.1/24'
    arp_scan(network)

Этот код будет сканировать сеть, представленную в виде CIDR (например, 192.168.1.1/24), и выводить список активных устройств с их IP- и MAC-адресами.

Подпишись 👉🏻 @KodduuPython 🤖

Управление браузером с Selenium driver:

from selenium import webdriver
from selenium.webdriver.common.by import By

browser = webdriver.Chrome()

# Открыть страницу
browser.get("https://google.com") 

# Найти элемент по css selector и ввести текст
search_field = browser.find_element(By.CSS_SELECTOR, "input[title='Поиск']")
search_field.send_keys("selenium python")

# Нажать кнопку поиска 
button = browser.find_element(By.CSS_SELECTOR, "input[value='Поиск Google']")
button.click()

# Получить текст заголовка первой страницы результатов
result = browser.find_element(By.TAG_NAME, "h3").text
print(result) 

# Закрыть браузер
browser.quit()

В этом примере используется библиотека selenium для управления браузером из кода.

Selenium позволяет автоматизировать взаимодействие с веб-страницами, как в этом случае - выполнить поиск на Google и получить результат.

Это полезный инструмент для тестирования или скрапинга веб-сайтов с помощью Python.

Подпишись 👉🏻 @KodduuPython 🤖

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

### Правила Синтаксиса

1. Одна команда или параметр на строку. Нет необходимости в скобках, кавычках или запятых, так как элементы отделены переносами строк.
2. Конец конструкции обозначается двойным переносом строки. Это помогает разграничить различные блоки кода.

### Примеры

1. Присваивание
Python Mobile:

   a
   =
   10
   

Обычный Python:

   a = 10
   

2. Условный оператор
Python Mobile:

   if
   a
   <
   15

   print
   Hello
   World
   

Обычный Python:

   if a < 15:
       print("Hello World")
   

3. Определение функции
Python Mobile:

   def
   add
   x
   y

   result
   =
   x
   +
   y

   return
   result
   

Обычный Python:

   def add(x, y):
       result = x + y
       return result
   

4. Цикл for
Python Mobile:

   for
   i
   in
   range
   0
   5

   print
   i
   

Обычный Python:

   for i in range(0, 5):
       print(i)
   

5. Импорт модуля
Python Mobile:

   import
   math
   as
   m
   

Обычный Python:

   import math as m
   

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

Подпишись 👉🏻 @KodduuPython 🤖