Dieses kleine Python-Skript verbessert das Verständnis der Low-Level-Programmierung

Ursprünglich veröffentlicht in Level Up Coding auf Medium.

---

Die Benutzerfreundlichkeit von Python verdeckt oft die zugrunde liegende Komplexität. Viele Entwickler gewöhnen sich an gängige Bibliotheken und Muster, was zu einem Plateau beim Lernen führt. Fortgeschrittene Themen wie Parallelität und Low-Level-Programmierung bieten jedoch erhebliche Wachstumschancen.

Der Podcast Talk Python To Me ist eine wertvolle Ressource für fortgeschrittenes Python-Lernen. Ihr Kurs „Parallel Programming in Python with async/await and threads“ bietet entscheidende Einblicke in Parallelität und Codeoptimierung.

Traditionelle Informatiklehrpläne behandeln häufig Computerarchitektur, C-Programmierung und Konzepte wie Mutexe, Semaphore und Zeiger. Dennoch kann die praktische Anwendung dieser Konzepte für viele Programmierer schwer zu fassen sein. Beispielsweise bleibt das Verständnis der CPU-Kernauslastung oft theoretisch.

Dieser Kurs stellt die unsync-Bibliothek vor, ein leistungsstarkes Tool zur Vereinfachung der gleichzeitigen und parallelen Programmierung. unsync vereint async, Threading und Multiprocessing in einer einzigen API und optimiert automatisch Aufgaben basierend darauf, ob sie CPU-gebunden, E/A-gebunden oder asynchron sind. Es rationalisiert die gleichzeitige Programmierung, indem es die Komplexität der Thread-Verwaltung bewältigt.

Das folgende Skript veranschaulicht diese Konzepte:

<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>

Skriptaufschlüsselung

Dieses Skript zeigt die gleichzeitige Aufgabenausführung für eine verbesserte Leistung:

1. compute_someFunktion: Führt intensive Berechnungen durch und demonstriert die Multithread-CPU-Kernauslastung. Zu den realen Anwendungen gehören wissenschaftliches Rechnen und Datenverarbeitung.
2. download_someFunktion: Lädt Daten asynchron herunter und nutzt aiohttp für nicht blockierende E/A. Ideal für Web Scraping und gleichzeitige API-Aufrufe.
3. download_some_moreFunktion:Verwendet synchrone Anforderungen in einem separaten Thread, geeignet für einfachere Szenarien, die Parallelität ohne nicht blockierende E/A erfordern.
4. wait_someFunktion: Simuliert asynchrone Verzögerungen, sodass andere Aufgaben gleichzeitig ausgeführt werden können. Nützlich für Aufgaben, bei denen auf externe Ereignisse gewartet werden muss.

Wichtige Lernpunkte

Das Skript hebt die Vorteile der gleichzeitigen Programmierung hervor: Die gleichzeitige Ausführung von Aufgaben führt zu einer schnelleren Verarbeitung und einer effizienteren Ressourcennutzung.

---

Eine effiziente Anwendungsentwicklung erfordert das Verständnis des Zusammenspiels zwischen Speicher (RAM) und Rechenleistung (CPU). RAM ermöglicht schnellen Zugriff auf Daten und ermöglicht reibungsloses Multitasking, während die CPU Anweisungen ausführt. Ausreichender Speicher ist für die Verarbeitung großer Datensätze und mehrerer Vorgänge von entscheidender Bedeutung, während eine leistungsstarke CPU schnelle Berechnungen und reaktionsschnelle Anwendungen gewährleistet. Das Verständnis dieser Beziehung ist für die Optimierung und effiziente Aufgabenverwaltung von entscheidender Bedeutung und führt zu leistungsstarken Anwendungen, die komplexe Aufgaben bewältigen können.

---

Foto von Alexander Kovalev

Das obige ist der detaillierte Inhalt vonDieses kleine Python-Skript verbessert das Verständnis der Low-Level-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!