Код для управления 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 🤖

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

Вот примерный код интерпретатора:

def interpret_python_mobile(code):
    # Разделяем код на строки
    lines = code.strip().split('\n')

    # Интерпретация блоков кода
    python_code = []
    current_block = []
    for line in lines:
        # Если строка пустая, значит это конец блока
        if line.strip() == '':
            if current_block:
                python_code.append(interpret_block(current_block))
                current_block = []
        else:
            current_block.append(line)

    # Обработка последнего блока, если он есть
    if current_block:
        python_code.append(interpret_block(current_block))

    return '\n'.join(python_code)

def interpret_block(block):
    """
    Интерпретирует отдельный блок кода Python Mobile.
    """
    # Пример простых преобразований
    if block[0] == 'if':
        # Собираем условие if
        return f"if {' '.join(block[1:])}:"
    elif block[0] == 'for':
        # Собираем цикл for
        return f"for {' '.join(block[1:])}:"
    elif '=' in block:
        # Обработка присваивания
        return f"{' '.join(block)}"
    elif block[0] == 'print':
        # Обработка print
        return f"print({' '.join(block[1:])})"
    # Добавьте здесь другие правила при необходимости
    else:
        # Возвращаем строку как есть
        return ' '.join(block)

# Пример использования
python_mobile_code = """
if
a
<
10

print
Hello
World
"""

interpreted_code = interpret_python_mobile(python_mobile_code)
print("Interpreted Python Code:\n", interpreted_code)

Этот код представляет собой базовую реализацию интерпретатора для вашего Python Mobile. Он интерпретирует некоторые базовые конструкции, такие как if, for и print. Для более сложных конструкций и дополнительных правил синтаксиса потребуется расширение и детализация логики интерпретатора.

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

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

### Обновленные Правила Синтаксиса

1. Одно слово или команда на строку. Нет необходимости в скобках, кавычках или запятых, так как элементы отделены переносами строк.

2. Продолжение слова на новой строке. Если слово или команда длинные, их можно разделить на несколько строк, используя символ "_" в конце каждой строки, кроме последней.

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

### Примеры с Обновленным Синтаксисом

1. Длинная команда
Python Mobile:

   very_long_
   command_name
   argument1
   argument2
   

Обычный Python:

   very_long_command_name(argument1, argument2)
   

2. Импорт с длинным названием модуля
Python Mobile:

   import
   very_long_
   module_name
   as
   mod
   

Обычный Python:

   import very_long_module_name as mod
   

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

Интерпретатор для учета нового правила синтаксиса:

def interpret_python_mobile_v3(code):
    """
    Updated interpreter for Python Mobile code with support for line continuation using '_'.
    """
    # Split the code into lines
    lines = code.strip().split('\n')

    # Process lines to handle line continuation ('_')
    processed_lines = []
    current_line = ''
    for line in lines:
        line = line.strip()
        if line.endswith('_'):
            # Remove '_' and continue the line without adding a space
            current_line += line[:-1]
        else:
            # Complete the current line and add it to the processed lines
            current_line += line
            processed_lines.append(current_line)
            current_line = ''  # Reset for the next block of lines

    # Interpret processed lines into Python code
    python_code = []
    block = []
    for line in processed_lines:
        if line == '':
            if block:
                python_code.append(interpret_block(block))
                block = []
        else:
            block.append(line)

    # Handle last block if present
    if block:
        python_code.append(interpret_block(block))

    return '\n'.join(python_code)

def interpret_block(block):
    """
    Interprets a single block of Python Mobile code.
    """
    if block[0] == 'if':
        return 'if ' + ' '.join(block[1:]) + ':'
    elif block[0] == 'for':
        return 'for ' + ' '.join(block[1:]) + ':'
    elif block[0] == 'print':
        return 'print(' + ', '.join(block[1:]) + ')'
    elif '=' in block:
        return ' '.join(block)
    elif block[0] == 'def':
        return 'def ' + block[1] + '(' + ', '.join(block[2:]) + '):'
    elif block[0] == 'import':
        return 'import ' + ' '.join(block[1:])
    # Add more cases for other Python Mobile syntax
    else:
        return ' '.join(block)

# Example use of the interpreter
python_mobile_code_example_v3 = """
pr_
int
Hel_
lo
Wo_rld
"""

interpreted_code_v3 = interpret_python_mobile_v3(python_mobile_code_example_v3)
print("Interpreted Python Code:\n", interpreted_code_v3)

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

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

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

Основные Особенности Python Lazy:

Параллельное Выполнение: Все строки кода выполняются одновременно. Если строка требует данных, которые еще не были сгенерированы, она будет ожидать их появления.

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

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

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

Пример ниже демонстрирует параллельное выполнение и зависимость выполнения строк от доступности данных. Давайте разберём этот пример шаг за шагом:

Имеем код:

1. print(a)
2. print(a + b)
3. a = 1
4. b = 2

Процесс выполнения:
1. Строка 1 (print(a)) начинает выполняться, но ожидает определения a.
2. Строка 2 (print(a + b)) также начинает выполняться, но она ожидает определения как a, так и b.
3. Строка 3 (a = 1) выполняется без ожидания, так как это независимое определение. После выполнения этой строки a становится доступным.
4. После того как a стало доступным, строка 1 может завершить своё выполнение и выводит 1.
5. Строка 4 (b = 2) выполняется без ожидания, определяя b.
6. После того как b стало доступным, строка 2 может завершить своё выполнение и выводит значение a + b, то есть 3.

Итак, порядок выполнения будет следующим:

1 -> wait for a -> 3 -> 1 -> print 1 -> stop
2 -> wait for a and b -> 3 -> 4 -> 2 -> print 3 -> stop
3 -> execute -> stop
4 -> execute -> stop

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

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

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

Этот интерпретатор будет:
1. Читать строки кода.
2. Определять, когда переменные становятся доступными.
3. Выполнять выражения, как только все необходимые данные станут доступны.

Давайте напишем простую версию на Python:

import re
from threading import Thread, Lock

class LazyPythonInterpreter:
    def __init__(self):
        self.variables = {}
        self.lock = Lock()
        self.threads = []

    def is_ready(self, expr):
        try:
            eval(expr, {}, self.variables)
            return True
        except NameError:
            return False
        except SyntaxError:
            return False

    def parse_line(self, line):
        if "=" in line:  # Assignment (expression)
            var, expr = map(str.strip, line.split('='))
            def assign():
                while not self.is_ready(expr):
                    pass
                with self.lock:
                    self.variables[var] = eval(expr, {}, self.variables)
            self.threads.append(Thread(target=assign))
        else:  # Statement
            def execute():
                while True:
                    with self.lock:
                        try:
                            exec(line, {}, self.variables)
                            break
                        except NameError:
                            continue
            self.threads.append(Thread(target=execute))

    def run(self, code):
        for line in code.split("\n"):
            self.parse_line(line.strip())

        for thread in self.threads:
            thread.start()
        for thread in self.threads:
            thread.join()

# Testing the interpreter
code = """
a = 1
b = 2
print(a)
print(a + b)
"""

interpreter = LazyPythonInterpreter()
interpreter.run(code)

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

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

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

Создание переводчика, учитывающего культурные различия между английским и русским языками, на основе книги "The Culture Map: Breaking Through the Invisible Boundaries of Global Business" Эрин Мейер, является сложной задачей. В книге рассматриваются различия в коммуникации, ведении переговоров, убеждениях и других аспектах межкультурного взаимодействия. Поэтому, для создания такого переводчика, нужно учитывать не только языковые различия, но и контекст, в котором используются определенные фразы или выражения.

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

Пример может выглядеть так:

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

Начнем с создания базового словаря и функции перевода:

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

cultural_differences_dict = {
    "yes": {
        "en": "Yes (can mean agreement or simply understanding)",
        "ru": "Да (может означать согласие и понимание, но также может использоваться для выражения уважения без явного согласия)"
    },
    "no": {
        "en": "No (direct and clear)",
        "ru": "Нет (часто используется менее прямо, возможно уклонение от прямого ответа для сохранения хороших отношений)"
    },
    # Добавим еще несколько примеров
    "maybe": {
        "en": "Maybe (often indicates openness to the idea but requires more information)",
        "ru": "Возможно (может означать сомнения и нежелание прямо отказывать)"
    },
    "I'll try": {
        "en": "I'll try (genuine intention to attempt, but not a promise)",
        "ru": "Попробую (может использоваться для избежания прямого отказа, не всегда подразумевает реальное намерение попытаться)"
    }
}

# Функция перевода с учетом культурных различий
def translate_with_cultural_context(phrase, from_lang, to_lang):
    if phrase in cultural_differences_dict:
        return cultural_differences_dict[phrase][to_lang]
    else:
        # Здесь может быть использован обычный переводчик, если фраза не найдена в словаре
        # Но в данном примере мы просто вернем фразу как есть
        return phrase

# Примеры использования функции
example_phrases = ["yes", "no", "maybe", "I'll try"]
translations = {phrase: translate_with_cultural_context(phrase, "en", "ru") for phrase in example_phrases}
translations

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

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