Η πολυεπεξεργασία της Python σάς επιτρέπει να κατανέμετε το φόρτο εργασίας σε πολλαπλές διεργασίες, μειώνοντας έτσι τον συνολικό χρόνο εκτέλεσης. Αυτό είναι ιδιαίτερα χρήσιμο για την εκτέλεση απαιτητικών υπολογισμών ή τη διαχείριση μεγάλων συνόλων δεδομένων.

Τι είναι η πολυεπεξεργασία Python;

Η πολυεπεξεργασία στην Python αναφέρεται στην ταυτόχρονη εκτέλεση πολλαπλών διεργασιών, επιτρέποντάς σας να αξιοποιήσετε στο έπακρο τα συστήματα πολλαπλών πυρήνων. Σε αντίθεση με τις μεθόδους ενός νήματος που χειρίζονται τις εργασίες μία προς μία, η πολυεπεξεργασία επιτρέπει σε διάφορα μέρη του προγράμματος να εκτελούνται παράλληλα, το καθένα ξεχωριστά. Κάθε διεργασία έχει το δικό της χώρο μνήμης και μπορεί να εκτελεστεί σε ξεχωριστούς πυρήνες επεξεργαστή, μειώνοντας δραστικά τον χρόνο εκτέλεσης για βαριές ή χρονοβόρες λειτουργίες.

Η πολυεπεξεργασία Python έχει ένα ευρύ φάσμα εφαρμογών. Η πολυεπεξεργασία χρησιμοποιείται συχνά στην επεξεργασία και ανάλυση δεδομένων για την ταχύτερη επεξεργασία μεγάλων συνόλων δεδομένων και την επιτάχυνση σύνθετων αναλύσεων. Η πολυεπεξεργασία μπορεί επίσης να χρησιμοποιηθεί σε προσομοιώσεις και υπολογισμούς μοντελοποίησης (π.χ. σε επιστημονικές εφαρμογές) για τη μείωση του χρόνου εκτέλεσης σύνθετων υπολογισμών. Εκτός από την ενίσχυση της διαδικτυακής συλλογής δεδομένων με την ταυτόχρονη λήψη δεδομένων από πολλαπλούς ιστότοπους, αυξάνει επίσης την αποδοτικότητα στην επεξεργασία εικόνων και την υπολογιστική όραση, με αποτέλεσμα την ταχύτερη ανάλυση εικόνων.

Πώς να εφαρμόσετε την πολυεπεξεργασία Python

Η Python προσφέρει διάφορες επιλογές για την υλοποίηση της πολυεπεξεργασίας. Στις επόμενες ενότητες, θα σας παρουσιάσουμε τρία κοινά εργαλεία: το multiprocessing module, τη concurrent.futures library και το joblib package.

multiprocessing ενότητα

Το multiprocessing module είναι το τυπικό module για την πολυεπεξεργασία Python. Με αυτό το module, μπορείτε να δημιουργήσετε διεργασίες, να μοιραστείτε δεδομένα μεταξύ τους και να τις συγχρονίσετε χρησιμοποιώντας κλειδώματα, ουρές και άλλα εργαλεία.

import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()
python

Στο παραπάνω παράδειγμα, χρησιμοποιούμε την κλάση multiprocessing.Process για να δημιουργήσουμε και να εκτελέσουμε διεργασίες που εκτελούν τη συνάρτηση task(), η οποία υπολογίζει το τετράγωνο ενός δεδομένου αριθμού. Μετά την αρχικοποίηση των διεργασιών, περιμένουμε να ολοκληρωθούν πριν προχωρήσουμε στο κύριο πρόγραμμα. Το αποτέλεσμα εμφανίζεται χρησιμοποιώντας μια συμβολοσειρά f, μια μέθοδος μορφοποίησης συμβολοσειράς Python που ενσωματώνει εκφράσεις. Αξίζει να σημειωθεί ότι η ακολουθία της εξόδου είναι τυχαία και μη ντετερμινιστική. Μπορείτε επίσης να δημιουργήσετε μια ομάδα διεργασιών με Python multiprocessing:

import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]
python

Με pool.map(), η συνάρτηση task() εφαρμόζεται σε μια ακολουθία δεδομένων και τα αποτελέσματα συλλέγονται και εξάγονται.

concurrent.futures βιβλιοθήκη

Αυτό το module παρέχει μια διεπαφή υψηλού επιπέδου για ασύγχρονη εκτέλεση και παράλληλη επεξεργασία διαδικασιών. Χρησιμοποιεί το Pool Executor για την εκτέλεση εργασιών σε ένα σύνολο διαδικασιών ή νημάτων. Το module concurrent.futures είναι ένας απλούστερος τρόπος επεξεργασίας ασύγχρονων εργασιών και σε πολλές περιπτώσεις είναι ευκολότερο στη χρήση από το module Python multiprocessing.

import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order
python

Ο κώδικας χρησιμοποιεί το concurrent.futures module για να επεξεργαστεί τις εργασίες παράλληλα με το ProcessPoolExecutor. Η συνάρτηση task(n) μεταβιβάζεται για αριθμούς από 1 έως 5. Η μέθοδος as_completed() περιμένει να ολοκληρωθούν οι εργασίες και εμφανίζει τα αποτελέσματα με οποιαδήποτε σειρά.

joblib πακέτο

joblib είναι μια εξωτερική βιβλιοθήκη Python που έχει σχεδιαστεί για να απλοποιεί την παράλληλη επεξεργασία σε Python, για παράδειγμα, για επαναλαμβανόμενες εργασίες όπως η εκτέλεση συναρτήσεων με διαφορετικές παραμέτρους εισόδου ή η εργασία με μεγάλες ποσότητες δεδομένων. Οι κύριες λειτουργίες του joblib είναι η παράλληλη επεξεργασία εργασιών, η αποθήκευση των αποτελεσμάτων των συναρτήσεων στην προσωρινή μνήμη και η βελτιστοποίηση της μνήμης και των υπολογιστικών πόρων.

from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: Results of the function for numbers from 1 to 10
python

Η έκφραση Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) ξεκινά την παράλληλη εκτέλεση της συνάρτησης task() για τους αριθμούς από 1 έως 10. Parallel έχει διαμορφωθεί με n_jobs=4, πράγμα που σημαίνει ότι μπορούν να επεξεργαστούν έως και τέσσερις παράλληλες εργασίες. Η κλήση delayed(task)(i) δημιουργεί την εργασία που θα εκτελεστεί παράλληλα για κάθε αριθμό i στην περιοχή από 1 έως 10. Αυτό σημαίνει ότι η συνάρτηση task() καλείται ταυτόχρονα για κάθε έναν από αυτούς τους αριθμούς. Τα αποτελέσματα για τους αριθμούς 1 έως 10 αποθηκεύονται στο results και εξάγονται.

Go to Main Menu