А, вот эта тема, блядь, про то, как в Питоне всё одновременно делать! Ну, там же не всё так просто, как кажется, ёпта. Смотри, есть три главных способа, и каждый — для своей, блядь, ситуации. Если выберешь не тот — будет пиздец, а не производительность.

1. Потоки (threading) Это когда ты думаешь: "О, да я щас в несколько потоков разгонюсь, как болид!" А на деле получается, что ты, сука, в одной машине сидишь, но с тремя рулями, и все они хотят крутить одно колесо. Это про I/O-bound задачи, то есть когда твоя программа не думает, а ждёт. Ждёт ответа от сервера, ждёт, пока файл запишется. Вот тут потоки — огонь. Потому что пока один поток спит, ожидая, другой может работать. Но если ты им дашь считать что-то сложное — нихуя не выйдет, из-за этой хуйни под названием GIL.

import threading
import requests

def fetch_url(url):
    print(f"Fetching {url}...")
    response = requests.get(url)
    print(f"Finished {url} with status {response.status_code}")

urls = [
    "https://www.google.com",
    "https://www.yandex.ru",
    "https://www.bing.com"
]

threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]
[t.start() for t in threads] # Запуск всех потоков
[t.join() for t in threads]  # Ожидание завершения всех потоков

Вот смотри: пока один поток ждёт ответа от Гугла, другой уже лезет на Яндексе. Красота, блядь.

2. Процессы (multiprocessing) А вот это уже серьёзно, ёпта. Это когда тебе надо не ждать, а реально пахать — считать, перемножать, обрабатывать. Потоки тут сдуются, потому что GIL их, как цепью, сковал. А процессы — это как завести отдельный цех на каждый станок. У каждого свой интерпретатор, своя память, и GIL им похуй. Истинный параллелизм, блядь! Но и ресурсов жрут, овердохуища.

from multiprocessing import Pool
import time

def heavy_computation(n):
    # Имитация тяжелых вычислений
    sum_val = 0
    for i in range(n):
        sum_val += i * i
    return sum_val

if __name__ == '__main__':
    numbers = [10**7, 10**7, 10**7, 10**7]
    with Pool() as p:
        results = p.map(heavy_computation, numbers)
    print(f"Results: {results}")

Вот тут каждый процесс берёт своё число и долбит его в одиночку, а потом результаты собираются. Для CPU-bound задач — то, что доктор прописал, в рот меня чих-пых.

3. Асинхронность (asyncio) А это, блядь, магия чистой воды. Ни потоков толком, ни процессов. Один поток, но внутри него куча задач, которые договариваются между собой: "Я подожду, ты работай". Кооперативная многозадачность, сука! Идеально, когда у тебя тысячи мелких операций ввода-вывода — запросы к API, веб-сокеты. Создавать на каждую операцию поток — это самоубийство, а asyncio всё в одном потоке управит.

import asyncio
import aiohttp

async def fetch_async(url):
    print(f"Async fetching {url}...")
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            print(f"Async finished {url} with status {response.status}")
            return await response.text()

async def main_async():
    urls = [
        "https://www.google.com",
        "https://www.yandex.ru",
        "https://www.bing.com"
    ]
    await asyncio.gather(*[fetch_async(url) for url in urls])

if __name__ == '__main__':
    asyncio.run(main_async())

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

Ну и под конец, блядь, важные детали:

• GIL (Global Interpreter Lock): Вот этот самый мудак, который не даёт потокам в Питоне нормально параллелиться на CPU. Он как охранник в клубе: пропускает только одного. Обойти можно процессами или, блядь, писать на Си.
• Синхронизация: А вот это, сука, самое опасное место. Когда несколько потоков или процессов лезут в одну переменную — это пиздец. Надо использовать замки (Lock), семафоры, очереди. В asyncio свои, асинхронные, причуды. Если забудешь — получишь race condition, и будет тебе весело, как в дурдоме.
• Выбор подхода: Тут, блядь, думать надо. Задача CPU-bound? Бери процессы. I/O-bound, но операций не миллион? Потоки сойдут. I/O-bound, да ещё и масштаб как у Гугла? Садись учи asyncio, дружок. Главное — не тыкать наугад, а то накосячишь так, что потом будешь ночами дебажить, ебать мои старые костыли.