Ускорение работы с данными с помощью numpy

import numpy as np
import timeit

# Создание больших массивов чисел
array_size = 10**6
python_list = list(range(array_size))
numpy_array = np.arange(array_size)

# Функция для суммирования элементов с использованием чистого Python
def sum_python(lst):
    return sum(lst)

# Функция для суммирования элементов с использованием numpy
def sum_numpy(arr):
    return np.sum(arr)

# Измерение времени выполнения для обеих функций
python_duration = timeit.timeit(lambda: sum_python(python_list), number=1)
numpy_duration = timeit.timeit(lambda: sum_numpy(numpy_array), number=1)

print(f"Python: {python_duration:.5f} seconds")
print(f"Numpy: {numpy_duration:.5f} seconds")

📌 Этот код демонстрирует, насколько быстрее numpy может обрабатывать большие массивы по сравнению с чистым Python. Используя numpy, можно значительно ускорить операции, такие как суммирование, благодаря оптимизированным C-расширениям. Это особенно полезно в научных и финансовых приложениях, где важна работа с большими объемами данных и высокая производительность.

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

🔮 Устойчивая обработка ошибок с монадами Maybe

from typing import Generic, TypeVar, Union, Callable

T = TypeVar('T')

class Maybe(Generic[T]):
    def __init__(self, value: Union[T, None]):
        self.value = value

    def is_nothing(self) -> bool:
        return self.value is None

    def map(self, func: Callable[[T], T]) -> 'Maybe[T]':
        if self.is_nothing():
            return self
        try:
            return Maybe(func(self.value))
        except Exception:
            return Maybe(None)

    def get_or_else(self, default: T) -> T:
        return self.value if not self.is_nothing() else default

# Пример использования
def safe_divide(x: float, y: float) -> Maybe[float]:
    if y == 0:
        return Maybe(None)
    return Maybe(x / y)

result = safe_divide(10, 2).map(lambda x: x * 100).get_or_else(0)
print(result)  # Вывод: 500.0

result = safe_divide(10, 0).map(lambda x: x * 100).get_or_else(0)
print(result)  # Вывод: 0

📌 Монада Maybe помогает избежать ошибок, связанных с использованием None или делением на ноль. Вместо выбрасывания исключений, функция возвращает объект Maybe, который можно безопасно обрабатывать с помощью методов map и get_or_else. Это делает код более предсказуемым и устойчивым к ошибкам, особенно полезно в API-интерфейсах и при работе с неполными данными.

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

💡 Управление светодиодами с MicroPython

from machine import Pin
from time import sleep

def blink_led(pin_number: int, delay: float = 0.5):
    try:
        led = Pin(pin_number, Pin.OUT)
        while True:
            led.on()
            sleep(delay)
            led.off()
            sleep(delay)
    except KeyboardInterrupt:
        print("Программа остановлена пользователем")
    except Exception as e:
        print(f"Произошла ошибка: {e}")

# Пример использования
if __name__ == "__main__":
    blink_led(pin_number=2)

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

MicroPython предоставляет более высокий уровень абстракции над аппаратными компонентами по сравнению с C/C++, что упрощает процесс разработки и прототипирования. Данный пример может быть полезен для создания простых устройств, таких как индикаторы состояния или световые эффекты в проектах с микроконтроллерами.

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

Создаем AI для игровых персонажей на Python 🎮

import random

class NPC:
    def __init__(self, name: str):
        self.name = name
        self.position = (0, 0)
    
    def patrol(self):
        # Перемещение в случайном направлении
        self.position = (self.position[0] + random.choice([-1, 1]),
                         self.position[1] + random.choice([-1, 1]))
        print(f"{self.name} патрулирует: {self.position}")
    
    def chase(self, target_position):
        # Перемещение в сторону цели
        direction_x = 0 if target_position[0] == self.position[0] else (1 if target_position[0] > self.position[0] else -1)
        direction_y = 0 if target_position[1] == self.position[1] else (1 if target_position[1] > self.position[1] else -1)
        self.position = (self.position[0] + direction_x,
                         self.position[1] + direction_y)
        print(f"{self.name} преследует игрока: {self.position}")

    def evade(self, threat_position):
        # Уклонение от угрозы
        direction_x = 0 if threat_position[0] == self.position[0] else (-1 if threat_position[0] > self.position[0] else 1)
        direction_y = 0 if threat_position[1] == self.position[1] else (-1 if threat_position[1] > self.position[1] else 1)
        self.position = (self.position[0] + direction_x,
                         self.position[1] + direction_y)
        print(f"{self.name} уклоняется от угрозы: {self.position}")

# Пример использования
npc = NPC("Гоблин")
npc.patrol()
npc.chase((5, 5))
npc.evade((3, 3))

📌 В этом коде реализован простой AI для NPC в играх. Он может патрулировать, преследовать игрока и уклоняться от угроз. Такой подход позволяет сделать игровой процесс более интерактивным и интересным.

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

💡 Lazy Evaluation и генераторы для обработки больших файлов

import logging

def read_large_file(file_path):
    try:
        with open(file_path, 'r') as file:
            yield from (line.strip() for line in file)
    except FileNotFoundError:
        logging.error(f"Файл {file_path} не найден.")
    except Exception as e:
        logging.error(f"Произошла ошибка: {e}")

def process_log_file(file_path):
    total_lines = 0
    error_count = 0

    for line in read_large_file(file_path):
        total_lines += 1
        if "ERROR" in line:
            error_count += 1

    return total_lines, error_count

# Пример использования
file_path = "server.log"
total_lines, error_count = process_log_file(file_path)
print(f"Всего строк: {total_lines}, ошибок: {error_count}")

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

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

🔄 Функциональные потоки данных с использованием itertools

from itertools import islice, chain

def process_large_data(data):
    # Пример использования itertools.chain для объединения нескольких списков
    combined_data = chain(data, ['дополнительно', 'данные'])
    
    # Пример использования itertools.islice для ленивой выборки данных
    sliced_data = islice(combined_data, 5)  # Возьмем только первые 5 элементов
    
    return list(sliced_data)

# Пример использования
data = ['элемент1', 'элемент2', 'элемент3']
print(process_large_data(data))

📌 Библиотека itertools предоставляет мощные инструменты для работы с итераторами, что помогает обрабатывать большие объемы данных эффективно. В этом примере chain объединяет списки, а islice позволяет отбирать элементы без использования циклов, что экономит память и улучшает производительность.

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

🎮 Разработка многопользовательской игры на Python с WebSockets

import asyncio
import websockets

connected_clients = set()

async def handle_connection(websocket, path):
    # Добавляем нового клиента в список подключений
    connected_clients.add(websocket)
    try:
        async for message in websocket:
            # Рассылаем сообщение всем подключенным клиентам
            await asyncio.gather(*[client.send(message) for client in connected_clients])
    except websockets.exceptions.ConnectionClosed:
        print(f"Клиент отключился: {websocket}")
    finally:
        # Удаляем клиента из списка подключений при отключении
        connected_clients.remove(websocket)

async def start_server():
    # Запуск WebSocket сервера на указанном порту
    server = await websockets.serve(handle_connection, "localhost", 8765)
    print("Сервер запущен на ws://localhost:8765")
    await server.wait_closed()

# Запуск сервера
asyncio.run(start_server())

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

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

🚀 Оптимизация производительности с помощью Cython

# example_cython.pyx
def cython_function(int n):
    cdef int i, total = 0
    for i in range(n):
        total += i
    return total

# Python-функция для сравнения
def python_function(n: int) -> int:
    total = 0
    for i in range(n):
        total += i
    return total

# Пример использования
if __name__ == "__main__":
    from time import time
    import pyximport
    pyximport.install()

    # Импортируем скомпилированный модуль
    import example_cython

    n = 10000000

    start = time()
    result_python = python_function(n)
    end = time()
    print(f"Python: {end - start:.2f} seconds, Result: {result_python}")

    start = time()
    result_cython = example_cython.cython_function(n)
    end = time()
    print(f"Cython: {end - start:.2f} seconds, Result: {result_cython}")

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

🛠 pip install Cython

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

🔌 Автоматизация сетевого администрирования с Paramiko

import paramiko
from paramiko.ssh_exception import SSHException, NoValidConnectionsError, AuthenticationException

def execute_ssh_command(host: str, username: str, password: str, command: str) -> str:
    try:
        with paramiko.SSHClient() as client:
            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            client.connect(hostname=host, username=username, password=password)
            
            stdin, stdout, stderr = client.exec_command(command)
            result = stdout.read().decode().strip()
            
            return result
    
    except AuthenticationException:
        return "Authentication failed, please verify your credentials."
    except (SSHException, NoValidConnectionsError) as e:
        return f"SSH Error: {e}"
    except Exception as e:
        return f"Unexpected Error: {e}"

# Пример использования
output = execute_ssh_command('192.168.1.1', 'admin', 'password123', 'show ip interface brief')
print(output)

📌 Этот код демонстрирует, как использовать библиотеку Paramiko для автоматизации SSH-подключений и выполнения команд на удалённых устройствах. Функция execute_ssh_command подключается к сетевому устройству по SSH, выполняет указанную команду и возвращает её результат. Это полезно для автоматизации задач сетевого администрирования, таких как мониторинг и управление устройствами.

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

💡 Управляем освещением с помощью Raspberry Pi и Python

import RPi.GPIO as GPIO
import time

def setup_gpio(pin: int):
    """Настройка GPIO-пина для вывода"""
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(pin, GPIO.OUT)
    GPIO.output(pin, GPIO.LOW)

def toggle_light(pin: int, duration: int):
    """Включает свет на заданное время, затем выключает"""
    try:
        setup_gpio(pin)
        GPIO.output(pin, GPIO.HIGH)
        print("Свет включен.")
        time.sleep(duration)
        GPIO.output(pin, GPIO.LOW)
        print("Свет выключен.")
    except Exception as e:
        print(f"Ошибка: {e}")
    finally:
        GPIO.cleanup(pin)  # Очищаем только используемый пин

# Пример использования
if __name__ == "__main__":
    toggle_light(pin=18, duration=5)

📌 Этот скрипт управляет светодиодом, подключенным к Raspberry Pi, включая и выключая его на заданное время. Используется библиотека RPi.GPIO для настройки пина в режиме вывода. Это может быть полезно для создания простых систем управления освещением в умном доме.

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

🌍 Создание процедурно-генерируемого мира с Perlin Noise

import numpy as np
from noise import pnoise2
import matplotlib.pyplot as plt

def generate_height_map(width: int, height: int, scale: float) -> np.ndarray:
    height_map = np.zeros((width, height))
    
    for x in range(width):
        for y in range(height):
            height_map[x][y] = pnoise2(x / scale, y / scale, octaves=6, persistence=0.5, lacunarity=2.0)
    
    return height_map

def display_height_map(height_map: np.ndarray):
    plt.imshow(height_map, cmap='terrain')
    plt.colorbar()
    plt.title("Procedurally Generated World")
    plt.show()

# Пример использования
width, height, scale = 100, 100, 50.0
height_map = generate_height_map(width, height, scale)
display_height_map(height_map)

📌 Этот код показывает, как использовать Perlin Noise для создания процедурно-генерируемой карты высот. Функция generate_height_map создает двумерный массив высот, применяя параметры шума, такие как октавы и масштаб. Это полезно для игр, требующих уникального ландшафта, например, roguelike или sandbox.

🛠 pip install noise matplotlib

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

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

WP умер, перевёл все сайты на DarwinClaw (аналог OpenClaw)

Раньше часто использовал WordPress с кучей плагинов для создания сайтов и лендингов. Сейчас поставил DarwinClaw на чистую машину Ubuntu и сказал ему сделать всю инфраструктуру для сайтов. Он поставил nginx + node.js.

Потом попросил перенести сайты, указав ссылки на них. Он создал все сайты.

Попросил добавить git и репозиторий для хранения этих сайтов. То есть всегда можно быстро откатить изменения.

Теперь полностью управляю этим зоопарком лендингов через TG команды типа:
- Убери с сайта X вот это
- Добавь на сайт Y вот то
- Поменяй стиль сайта Z на ...
- Откати последние изменения на сайте XM
- Замени икноку на сайте XS на более современную
- Собери статистику по заполнению форм с сайтов X, Y, Z в формате

Раньше это либо делали люди за деньги, либо WP с его тяжёлой инфраструктурой, теперь всё делает бот на DarwinClaw. Примерно то же самое можно сделать на OpenClaw.

#КЕЙС

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

⚡️ Эффективная работа с большими данными через Dask

import dask.array as da

def compute_large_array_sum(array_size: int) -> float:
    try:
        # Создаем большой Dask массив
        large_array = da.random.random((array_size, array_size), chunks=(1000, 1000))
        
        # Вычисляем сумму всех элементов
        total_sum = large_array.sum().compute()
        return total_sum
    except Exception as e:
        print(f"Ошибка при вычислении: {e}")
        return 0.0

# Пример использования
if __name__ == "__main__":
    size = 10000  # Размер массива 10000x10000
    total = compute_large_array_sum(size)
    print(f"Сумма элементов массива: {total}")

📌 Этот код демонстрирует, как использовать Dask для обработки больших объемов данных. Мы создаем массив случайных чисел и вычисляем их сумму, применяя Dask для распределённых вычислений. Такой подход позволяет работать с массивами, которые не помещаются в оперативную память, и ускоряет вычисления.

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

WP умер, перевёл все сайты на DarwinClaw (аналог OpenClaw)

Раньше часто использовал WordPress с кучей плагинов для создания сайтов и лендингов. Сейчас поставил DarwinClaw на чистую машину Ubuntu и сказал ему сделать всю инфраструктуру для сайтов. Он поставил nginx + node.js.

Потом попросил перенести сайты, указав ссылки на них. Он создал все сайты.

Попросил добавить git и репозиторий для хранения этих сайтов. То есть всегда можно быстро откатить изменения.

Теперь полностью управляю этим зоопарком лендингов через TG команды типа:
- Убери с сайта X вот это
- Добавь на сайт Y вот то
- Поменяй стиль сайта Z на ...
- Откати последние изменения на сайте XM
- Замени икноку на сайте XS на более современную
- Собери статистику по заполнению форм с сайтов X, Y, Z в формате

Раньше это либо делали люди за деньги, либо WP с его тяжёлой инфраструктурой, теперь всё делает бот на DarwinClaw. Примерно то же самое можно сделать на OpenClaw.

#КЕЙС

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

🎮 Мультиплеерные игры на Python: создание сетевого взаимодействия

import asyncio

async def handle_client(reader, writer):
    try:
        while True:
            data = await reader.read(100)
            if not data:
                break
            message = data.decode()
            print(f"Received: {message}")
            writer.write(data)
            await writer.drain()
    except Exception as e:
        print(f"Error: {e}")
    finally:
        writer.close()
        await writer.wait_closed()

async def main(host='127.0.0.1', port=8888):
    server = await asyncio.start_server(handle_client, host, port)
    async with server:
        print(f"Server listening on {host}:{port}")
        await server.serve_forever()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("Server stopped")

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

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

📸 Эффективная обработка изображений с OpenCV и multiprocessing

import cv2
import os
from multiprocessing import Pool

def process_image(image_path: str, output_dir: str):
    try:
        image = cv2.imread(image_path)
        if image is None:
            raise ValueError(f"Cannot open image {image_path}")
        
        # Пример обработки: изменение размера изображения
        resized_image = cv2.resize(image, (100, 100))
        _, filename = os.path.split(image_path)
        output_path = os.path.join(output_dir, filename)
        cv2.imwrite(output_path, resized_image)
        print(f"Processed {filename}")
    except Exception as e:
        print(f"Error processing {image_path}: {e}")

def parallel_image_processing(input_dir: str, output_dir: str, num_workers: int = 4):
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    image_files = [os.path.join(input_dir, f) for f in os.listdir(input_dir) if f.endswith(('.png', '.jpg', '.jpeg'))]
    
    with Pool(processes=num_workers) as pool:
        pool.starmap(process_image, [(image_path, output_dir) for image_path in image_files])

# Пример использования
input_directory = 'images/input'
output_directory = 'images/output'
parallel_image_processing(input_directory, output_directory)

📌 Этот код демонстрирует, как можно ускорить обработку изображений с помощью OpenCV и библиотеки multiprocessing. Он параллельно изменяет размер изображений из указанной директории, что значительно повышает производительность при работе с большими наборами данных. Это полезно для приложений компьютерного зрения, где обработка изображений является частой задачей.

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

Как применить OpenClaw в вашей компании?

Многие сейчас просят перейти на технологию OpenClaw. Но для начала важно понимать, что это и как оно может функционировать в B2B/Enterprise.

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

Во-вторых, OpenClaw умеет делать почти все, но это достигается за счёт полного доступа к компьютеру, на котором он запускается. Это требует много ресурсов (от ~1000 руб с функцией браузинга в месяц за виртуальную машину для каждого сотрудника).

Поэтому нужен новый OpenClaw для B2B/Enterprise, который сможет быть индивидуальным ботом для каждого сотрудника при неизменности общих знаний и без возможности получить чужие персональные данные и знания.

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

И конечно, эта версия должна быть безопаснее - защита от prompt injections и доступы к данным компании по ролям через single sign-on компании.

К сожалению, таких версий нет в open source. Поэтому мы начали разрабатывать свою версию OpenClaw (DarwinClaw.RU) как раз для B2B/Enterprise.

На тестирование новой версии записывайтесь здесь. Мы уже начинаем внедрение в двух очень больших компаниях.

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

🔄 Реактивное программирование с RxPy

from rx import create
from rx.operators import filter, map
from rx.core.typing import Observer, Scheduler

def event_stream(observer: Observer, scheduler: Scheduler):
    # Список событий для обработки
    events = [1, 2, 3, 4, 5, 6]
    for event in events:
        observer.on_next(event)  # Передаем событие в поток
    observer.on_completed()  # Завершаем поток

def handle_event(event):
    print(f"Обработано событие: {event}")

source = create(event_stream)

source.pipe(
    filter(lambda x: x % 2 == 0),  # Фильтруем только четные числа
    map(lambda x: x * 10)  # Масштабируем числа
).subscribe(
    on_next=handle_event,
    on_error=lambda e: print(f"Ошибка: {e}"),  # Обработка ошибок
    on_completed=lambda: print("Обработка завершена")  # Завершение обработки
)

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

🛠 pip install rx

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

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

🏠 Умный дом с Raspberry Pi и Python

import RPi.GPIO as GPIO
import time

# Настройка GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)  # Отключить предупреждения
LED_PIN = 18
GPIO.setup(LED_PIN, GPIO.OUT)

def toggle_light(state: bool):
    """Включает или выключает светодиод."""
    GPIO.output(LED_PIN, state)

try:
    # Пример использования: мигание светодиода
    for _ in range(5):
        toggle_light(True)
        time.sleep(1)
        toggle_light(False)
        time.sleep(1)
finally:
    GPIO.cleanup()

📌 Этот код управляет светодиодом на Raspberry Pi с помощью Python и библиотеки RPi.GPIO. Он включает и выключает светодиод с заданной периодичностью, что полезно для простых проектов умного дома, таких как управление освещением. Перед использованием убедитесь, что светодиод правильно подключен к пину GPIO 18.

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

OpenClaw пожиратель токенов

Все чаще слышу: "OpenClaw пожиратель токенов". Я и сам, когда поставил поиграться, сожрал токенов на $30 за несколько часов. Тем не менее, я уже использую два своих постоянных бота на OpenClaw (R2D2 и C3PO) и научился ограничивать его аппетиты.

Самые простые настройки для ограничения аппетита:
1. Запрет/сильное ограничение Base64-скриншотов и изображений в промпте (может сэкономить миллионы токенов на один скриншот).
2. Ограничить количество итераций ReAct Loop, чтобы избежать случаев, когда модель часами ходит по кругу, тратит токены и не может решить задачу.
3. Включить prompt pruning - обрезка ненужного в памяти прямо перед отправкой запроса модели. Он работает в памяти (in-memory) и не меняет историю на диске.
4. Уменьшить или убрать проверку состояния (каждые 30 минут по умолчанию).
5. Использовать разные модели для разных задач (не стоит использовать дорогую модель codex для не coding задач, для vision выбрать лучшую модель по соотношению цена/качество).
6. Поставить LiteLLM как прокси перед OpenClaw → включить кэш (cache hits экономят огромные деньги).

Каждое ограничение, конечно, ограничивает возможности OpenClaw, но зато экономит бюджет.

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

🚀 Асинхронное программирование с asyncio

import asyncio
import aiohttp

async def fetch_url(session, url):
    try:
        async with session.get(url) as response:
            return await response.text()
    except Exception as e:
        return f"Ошибка при загрузке {url}: {e}"

async def main(urls):
    if not urls:
        print("Список URL пуст.")
        return
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for url, content in zip(urls, results):
            print(f"Содержимое из {url[:50]}: {content[:100]}...")

urls = [
    "https://www.example.com",
    "https://www.python.org",
    "https://www.asyncio.org"
]
asyncio.run(main(urls))

📌 Этот код демонстрирует использование асинхронного программирования для параллельной загрузки веб-страниц. С помощью aiohttp и asyncio создается асинхронная сессия для выполнения HTTP-запросов, что позволяет обрабатывать несколько URL-адресов одновременно, ускоряя выполнение операций ввода-вывода. Это полезно для веб-скрейпинга и обработки множества сетевых запросов.

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