Gleichzeitige Zukünfte in Python: Einfaches Starten paralleler Aufgaben

Das Erreichen einer optimalen Leistung durch parallele Ausführung ist unerlässlich. Python, eine vielseitige Programmiersprache, bietet mehrere Tools für die gleichzeitige Ausführung. Eines der leistungsstärksten und benutzerfreundlichsten Module ist concurrent.futures, das es Entwicklern ermöglicht, Aufrufe asynchron auszuführen. In diesem Artikel untersuchen wir die Funktionalität dieses Moduls und wie Sie es für verschiedene Aufgaben nutzen können, einschließlich Dateioperationen und Webanfragen.

Übersicht über gleichzeitige Futures

Das concurrent.futures-Modul bietet eine abstrakte Klasse namens Executor, die die asynchrone Ausführung von Aufrufen erleichtert. Obwohl es nicht direkt verwendet werden sollte, können Entwickler seine konkreten Unterklassen wie ThreadPoolExecutor und ProcessPoolExecutor verwenden, um Aufgaben gleichzeitig auszuführen.

Hauptmerkmale

1. Submit-Methode: Bei der Submit-Methode geschieht die Magie. Es plant die asynchrone Ausführung einer aufrufbaren Funktion und gibt ein Future-Objekt zurück. Das Callable wird mit den bereitgestellten Argumenten ausgeführt, sodass Entwickler Hintergrundaufgaben nahtlos ausführen können.

   with ThreadPoolExecutor(max_workers=1) as executor:
       future = executor.submit(pow, 323, 1235)
       print(future.result())

In diesem Beispiel verwenden wir einen ThreadPoolExecutor, um eine Zahl in einem separaten Thread zu potenzieren.

1. Map-Methode: Die Map-Methode ist eine weitere fantastische Funktion, die die gleichzeitige Ausführung einer Funktion über mehrere Eingabe-Iterables hinweg ermöglicht. Es sammelt die Iterables sofort und führt die Aufrufe asynchron aus.

   results = executor.map(load_url, URLS, timeout=2)

Diese Funktionalität ist besonders nützlich, wenn Sie eine Liste von Aufgaben haben, die Sie parallel ausführen möchten.

Praktische Anwendung: Dateien kopieren

Stellen Sie sich ein Szenario vor, in dem Sie mehrere Dateien effizient kopieren müssen. Der folgende Codeausschnitt zeigt, wie ein ThreadPoolExecutor zum gleichzeitigen Kopieren von Dateien verwendet wird:

import concurrent.futures
import shutil

files_to_copy = [
    ('src2.txt', 'dest2.txt'),
    ('src3.txt', 'dest3.txt'),
    ('src4.txt', 'dest4.txt'),
]

with concurrent.futures.ThreadPoolExecutor() as executor:
    futures = [executor.submit(shutil.copy, src, dst) for src, dst in files_to_copy]
    for future in concurrent.futures.as_completed(futures):
        print(future.result())

In diesem Beispiel wird die Funktion „shutil.copy“ genutzt, um Dateikopien parallel durchzuführen und so die Leistung bei umfangreichen Dateivorgängen deutlich zu verbessern.

Gleichzeitige Bearbeitung von Webanfragen

Eine weitere spannende Anwendung des concurrent.futures-Moduls ist das gleichzeitige Abrufen von Inhalten von mehreren URLs. Unten finden Sie eine einfache Implementierung mit ThreadPoolExecutor zum Abrufen von Webseiten:

import concurrent.futures
import urllib.request

URLS = [
    'http://www.foxnews.com/',
    'http://www.cnn.com/',
    'http://europe.wsj.com/',
    'http://www.bbc.co.uk/',
    'http://nonexistant-subdomain.python.org/',
]

def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

with concurrent.futures.ThreadPoolExecutor() as executor:
    results = executor.map(load_url, URLS, timeout=2)
    for result in results:
        print(result)

Dieser Code ist eine einfache Möglichkeit, Webinhalte schnell abzurufen und zeigt, wie einfach es ist, die gleichzeitige Ausführung in Ihren Projekten zu implementieren.

Abschluss

Das concurrent.futures-Modul bietet eine leistungsstarke Möglichkeit, Aufgaben asynchron in Python auszuführen und so den Prozess der Erzielung von Parallelität in Ihren Anwendungen zu vereinfachen. Durch die Executor-Klasse und Methoden wie Submit und Map können Entwickler Hintergrundaufgaben effizient verwalten, unabhängig davon, ob es sich um Dateivorgänge, Webanforderungen oder andere E/A-gebundene Prozesse handelt.

Durch die Integration dieser Techniken in Ihre Programmierpraktiken können Sie reaktionsfähigere und effizientere Anwendungen erstellen und so sowohl die Leistung als auch das Benutzererlebnis verbessern. Viel Spaß beim Codieren!

Das obige ist der detaillierte Inhalt vonGleichzeitige Zukünfte in Python: Einfaches Starten paralleler Aufgaben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!