Купить два курса по Python оптом всего за 4980 2450 рублей можно на Stepik в созданной специализации Junior Python Developer 🤖

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

Распознавание капчи с помощью Python является сложной задачей, которая обычно требует применения техник машинного обучения и компьютерного зрения. Одним из распространенных подходов является использование сверточных нейронных сетей (CNN), которые способны извлекать особенности из изображений и классифицировать их. Однако создание эффективной системы для распознавания капчи требует большого объема данных для обучения и значительных вычислительных ресурсов.

Для более простых задач, где капча не содержит сложных искажений или шума, можно использовать библиотеки оптического распознавания символов (OCR), такие как Tesseract. Вот базовый пример, как можно попытаться распознать текст капчи с помощью Tesseract:

1. Установка Tesseract:
Убедитесь, что Tesseract установлен на вашей системе.

Ошибка pytesseract.pytesseract.TesseractNotFoundError: tesseract is not installed or it's not in your PATH указывает на то, что библиотека Tesseract OCR не установлена в вашей системе или путь к ее исполняемому файлу не включен в переменную окружения PATH.

Вот шаги, которые нужно выполнить, чтобы решить эту проблему:

### Установка Tesseract OCR

1. Установите Tesseract OCR. Вы можете скачать установщик для вашей операционной системы с [официального сайта Tesseract](https://github.com/tesseract-ocr/tesseract) или установить через менеджер пакетов вашей системы.

Для macOS (с использованием Homebrew):

   brew install tesseract
   

Для Ubuntu:

   sudo apt install tesseract-ocr
   

Проверьте, что Tesseract установлен корректно. Выполните в командной строке:

   tesseract --version
   

Если Tesseract установлен, вы увидите информацию о версии.

2. Установка Python-библиотеки pytesseract:

   pip install pytesseract
   

3. Использование Tesseract для распознавания текста на изображении капчи:

   import pytesseract
   from PIL import Image

   # Загрузка изображения капчи
   captcha_image = Image.open("path_to_captcha_image.png")

   # Использование Tesseract для распознавания текста
   captcha_text = pytesseract.image_to_string(captcha_image)

   print("Распознанный текст капчи:", captcha_text.strip())
   

Этот код пытается распознать текст на изображении капчи, используя Tesseract. Однако, если капча содержит сложные шумы, искажения или перекрытия, Tesseract может не справиться с задачей. В таких случаях обычно требуется предварительная обработка изображения (например, удаление шума, коррекция контраста) или использование более сложных методов распознавания с использованием нейронных сетей.

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

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

1. Предварительная обработка изображения: Улучшение качества изображения перед его подачей в Tesseract может значительно улучшить результаты распознавания. К таким методам относятся изменение контрастности, бинаризация изображения, удаление шума и т.д.

Пример предварительной обработки с использованием библиотеки Pillow:

   from PIL import Image, ImageFilter, ImageEnhance

   def preprocess_image(image_path):
       image = Image.open(image_path)
       image = image.convert('L')  # Преобразование в черно-белое
       image = ImageEnhance.Contrast(image).enhance(2)  # Увеличение контраста
       image = image.filter(ImageFilter.MedianFilter())  # Применение фильтра для сглаживания
       return image

   captcha_image = preprocess_image("path_to_captcha_image.png")
   captcha_text = pytesseract.image_to_string(captcha_image)
   

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

Пример указания использования только цифр:

   captcha_text = pytesseract.image_to_string(captcha_image, config='--psm 6 digits')
   

3. Тренировка Tesseract на специфических шрифтах капчи: Если капча использует нестандартные шрифты, можно обучить Tesseract распознавать эти конкретные шрифты, хотя это достаточно сложный и трудоемкий процесс.

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

Создание резюме для junior разработчика Python может быть выполнено с помощью библиотеки Python для работы с документами, например python-docx. Эта библиотека позволяет создавать документы в формате Word (.docx). Для начала установите библиотеку, если она еще не установлена:

pip install python-docx

Затем вы можете использовать следующий пример кода для генерации простого резюме:

from docx import Document
from docx.shared import Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH

# Функция для добавления заголовка
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)

# Создаем документ
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)
add_paragraph(doc, 'Бакалавр информатики, МГУ, 2022')

# Навыки
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.docx')

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

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

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

Для вставки гиперссылки в документ 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 🤖