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

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 🤖

Чтобы создать интерпретатор для этого нового синтаксиса 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 🤖