Ce petit script Python a amélioré la compréhension de la programmation de bas niveau

Publié à l'origine dans Level Up Coding sur Medium.

---

La facilité d'utilisation de Python masque souvent les complexités sous-jacentes. De nombreux développeurs se familiarisent avec les bibliothèques et les modèles courants, ce qui conduit à un plateau dans l'apprentissage. Cependant, des sujets avancés tels que la concurrence et la programmation de bas niveau offrent d'importantes opportunités de croissance.

Le podcast Talk Python To Me est une ressource précieuse pour l'apprentissage avancé de Python. Leur cours, « Programmation parallèle en Python avec async/await et threads », fournit des informations cruciales sur la concurrence et l'optimisation du code.

Les programmes d'études traditionnels en informatique couvrent souvent l'architecture informatique, la programmation C et des concepts tels que les mutex, les sémaphores et les pointeurs. Pourtant, l’application pratique de ces concepts peut rester insaisissable pour de nombreux programmeurs. Comprendre l'utilisation du cœur du processeur, par exemple, reste souvent théorique.

Ce cours met en avant la bibliothèque unsync, un outil puissant simplifiant la programmation concurrente et parallèle. unsync unifie async, le threading et le multitraitement en une seule API, optimisant automatiquement les tâches selon qu'elles sont liées au processeur, aux E/S ou asynchrones. Il rationalise la programmation simultanée en gérant les complexités de gestion des threads.

Le script suivant illustre ces concepts :

<code class="language-python"># source: https://github.com/talkpython/async-techniques-python-course/blob/master/src/09-built-on-asyncio/the_unsync/thesync.py

import datetime
import math
import asyncio
import aiohttp
import requests
from unsync import unsync

def main():
    start_time = datetime.datetime.now()

    tasks = [
        compute_some(),
        compute_some(),
        compute_some(),
        download_some(),
        download_some(),
        download_some_more(),
        download_some_more(),
        wait_some(),
        wait_some(),
        wait_some(),
        wait_some(),
    ]

    [t.result() for t in tasks]

    end_time = datetime.datetime.now()
    elapsed_time = end_time - start_time
    print(f"Synchronous version completed in {elapsed_time.total_seconds():,.2f} seconds.")

@unsync(cpu_bound=True)
def compute_some():
    print("Performing computation...")
    for _ in range(1, 10_000_000):
        math.sqrt(25 ** 25 + .01)

@unsync()
async def download_some():
    print("Downloading...")
    url = 'https://talkpython.fm/episodes/show/174/coming-into-python-from-another-industry-part-2'
    async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
        async with session.get(url) as resp:
            resp.raise_for_status()
            text = await resp.text()
    print(f"Downloaded (more) {len(text):,} characters.")

@unsync()
def download_some_more():
    print("Downloading more...")
    url = 'https://pythonbytes.fm/episodes/show/92/will-your-python-be-compiled'
    resp = requests.get(url)
    resp.raise_for_status()
    text = resp.text
    print(f"Downloaded {len(text):,} characters.")

@unsync()
async def wait_some():
    print("Waiting...")
    for _ in range(1, 1000):
        await asyncio.sleep(.001)

if __name__ == "__main__":
    main()</code>

Répartition du script

Ce script présente l'exécution de tâches simultanées pour des performances améliorées :

1. compute_some Fonction : Effectue des calculs intensifs, démontrant l'utilisation du cœur du processeur multithread. Les applications du monde réel incluent le calcul scientifique et le traitement des données.
2. download_some Fonction : Télécharge les données de manière asynchrone, en utilisant aiohttp pour les E/S non bloquantes. Idéal pour le web scraping et les appels API simultanés.
3. download_some_more Fonction : Utilise des requêtes synchrones dans un thread séparé, adapté aux scénarios plus simples nécessitant une concurrence sans E/S non bloquantes.
4. wait_some Fonction : Simule des retards asynchrones, permettant à d'autres tâches de se dérouler simultanément. Utile pour les tâches impliquant l'attente d'événements externes.

Points d'apprentissage clés

Le script met en évidence les avantages de la programmation simultanée : l'exécution simultanée de tâches conduit à un traitement plus rapide et à une utilisation plus efficace des ressources.

---

Le développement efficace d'applications nécessite de comprendre l'interaction entre la mémoire (RAM) et la puissance de traitement (CPU). La RAM offre un accès rapide aux données, permettant un multitâche fluide, tandis que le processeur exécute les instructions. Une mémoire adéquate est cruciale pour gérer des ensembles de données volumineux et des opérations multiples, tandis qu'un processeur puissant garantit des calculs rapides et des applications réactives. Comprendre cette relation est essentiel pour l'optimisation et la gestion efficace des tâches, conduisant à des applications hautes performances capables de gérer des tâches complexes.

---

Photo d'Alexandre Kovalev

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!