כיצד לשפר את קוד הפייתון שלך במקביל ובמקביליות

טייק אווי מפתח

• מקביליות ומקבילות הם עקרונות בסיסיים של ביצוע מטלות במחשוב, כאשר לכל אחד מהם המאפיינים הייחודיים שלו.
• במקביליות מאפשרת ניצול יעיל של משאבים ותגובתיות משופרת של יישומים, בעוד שהמקביליות היא חיונית לביצועים מיטביים ומדרגיות.
• Python מספקת אפשרויות לטיפול במקביל, כגון שרשור ותכנות אסינכרוני עם asyncio, כמו גם מקביליות באמצעות מודול ריבוי עיבודים.

מקביליות ומקבילות הן שתי טכניקות המאפשרות לך להפעיל מספר תוכניות בו זמנית. לפייתון יש מספר אפשרויות לטיפול במשימות במקביל ובמקביל, מה שעלול לבלבל.

חקור את הכלים והספריות הזמינים ליישום נכון של מקביליות ומקביליות ב-Python, וכיצד הם שונים.

הבנת מקביליות ומקביליות

מקביליות ומקבילות מתייחסות לשני עקרונות יסוד של ביצוע משימות במחשוב. לכל אחד יש את המאפיינים המובהקים שלו.

1. במקביל היא היכולת של תוכנית לנהל משימות מרובות בו זמנית מבלי בהכרח לבצע אותן באותו זמן בדיוק. הוא סובב סביב הרעיון של שילוב משימות, מעבר ביניהן באופן שנראה בו-זמנית.
2. מַקבִּילוּת, מצד שני, כרוך בביצוע משימות מרובות באמת במקביל. זה בדרך כלל מנצל
   instagram viewer
   מספר ליבות CPU או מעבדים. מקביליות משיגה ביצוע בו-זמני אמיתי, מאפשרת לך לבצע משימות מהר יותר, והיא מתאימה היטב לפעולות אינטנסיביות מבחינה חישובית.

החשיבות של מקביליות ומקביליות

אי אפשר להפריז בצורך במקבילות ובמקביליות במחשוב. הנה הסיבה לטכניקות אלו חשובות:

1. ניצול משאבים: במקביל מאפשרת ניצול יעיל של משאבי המערכת, ומבטיחה שהמשימות מתקדמות באופן אקטיבי במקום להמתין בחוסר מעש למשאבים חיצוניים.
2. היענות: במקביל יכולה לשפר את ההיענות של יישומים, במיוחד בתרחישים הכוללים ממשקי משתמש או שרתי אינטרנט.
3. ביצועים: מקביליות חיונית להשגת ביצועים מיטביים, במיוחד במשימות הקשורות למעבד כמו חישובים מורכבים, עיבוד נתונים וסימולציות.
4. מדרגיות: גם במקביליות וגם מקביליות חיוניות לבניית מערכות ניתנות להרחבה.
5. הוכחה לעתיד: ככל שמגמות החומרה ממשיכות להעדיף מעבדים מרובי ליבות, היכולת לרתום מקביליות תיהיה נחוצה יותר ויותר.

במקביל ב-Python

אתה יכול להשיג במקביל ב- Python באמצעות שרשור ותכנות אסינכרוני עם ספריית asyncio.

שרשור ב-Python

שרשור הוא מנגנון מקבילות של Python המאפשר לך ליצור ולנהל משימות בתוך תהליך בודד. שרשורים מתאימים לסוגים מסוימים של משימות, במיוחד כאלו שהן קשורות ל-I/O ויכולות להפיק תועלת מביצוע במקביל.

של פייתון הַשׁחָלָה מודול מספק ממשק ברמה גבוהה ליצירה וניהול שרשורים. בעוד ש-GIL (Global Interpreter Lock) מגביל פתילים במונחים של מקביליות אמיתית, הם עדיין יכולים להשיג במקביל על ידי שזירת משימות ביעילות.

הקוד שלהלן מציג דוגמה ליישום של מקביליות באמצעות שרשורים. הוא משתמש בספריית הבקשות של Python כדי לשלוח בקשת HTTP, משימת חסימת I/O נפוצה. הוא גם משתמש ב- מודול זמן לחישוב זמן ביצוע.

import requests
import time
import threading
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# function to request a URL
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")
# Execute without threads and measure execution time
start_time = time.time()
for url in urls:
 download_url(url)
end_time = time.time()
print(f"Sequential download took {end_time - start_time:.2f} seconds\n")
# Execute with threads, resetting the time to measure new execution time
start_time = time.time()
threads = []
for url in urls:
 thread = threading.Thread(target=download_url, args=(url,))
 thread.start()
 threads.append(thread)
# Wait for all threads to complete
for thread in threads:
 thread.join()
end_time = time.time()
print(f"Threaded download took {end_time - start_time:.2f} seconds")

הפעלת תוכנית זו, אתה אמור לראות כמה מהר יותר הבקשות המשורשרות מהבקשות הרציפות. למרות שההבדל הוא רק שבריר שנייה, אתה מקבל תחושה ברורה של שיפור הביצועים בעת שימוש בשרשורים עבור משימות הקשורות ל-I/O.

תכנות אסינכרוני עם Asyncio

אסינציו מספק לולאת אירועים המנהלת משימות אסינכרוניות הנקראות קורוטינים. Coroutines הם פונקציות שאתה יכול להשהות ולחדש, מה שהופך אותן לאידיאליות עבור משימות הקשורות ל-I/O. הספרייה שימושית במיוחד עבור תרחישים שבהם משימות כוללות המתנה למשאבים חיצוניים, כגון בקשות רשת.

אתה יכול לשנות את הדוגמה הקודמת לשליחת הבקשות לעבוד איתה אסינציו:

import asyncio
import aiohttp
import time
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# asynchronous function to request URL
asyncdefdownload_url(url):
asyncwith aiohttp.ClientSession() as session:
asyncwith session.get(url) as response:
 content = await response.text()
 print(f"Downloaded {url} - Status Code: {response.status}")
# Main asynchronous function
asyncdefmain():
# Create a list of tasks to download each URL concurrently
 tasks = [download_url(url) for url in urls]
# Gather and execute the tasks concurrently
await asyncio.gather(*tasks)
start_time = time.time()
# Run the main asynchronous function
asyncio.run(main())
end_time = time.time()
print(f"Asyncio download took {end_time - start_time:.2f} seconds")

באמצעות הקוד, תוכל להוריד דפי אינטרנט במקביל באמצעות אסינציו ולנצל את פעולות I/O אסינכרוניות. זה יכול להיות יעיל יותר מהשרשור עבור משימות הקשורות ל-I/O.

מקביליות בפייתון

אתה יכול ליישם מקביליות באמצעות של פייתון ריבוי עיבודים מודול, המאפשר לך לנצל את מלוא היתרונות של מעבדים מרובי ליבות.

ריבוי עיבודים בפייתון

של פייתון ריבוי עיבודים מודול מספק דרך להשיג מקביליות על ידי יצירת תהליכים נפרדים, שלכל אחד מהם מתורגמן Python ומרחב זיכרון משלו. זה עוקף למעשה את מנעול המתורגמן הגלובלי (GIL), מה שהופך אותו למתאים למשימות הקשורות למעבד.

import requests
import multiprocessing
import time
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# function to request a URL
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")
defmain():
# Create a multiprocessing pool with a specified number of processes
 num_processes = len(urls)
 pool = multiprocessing.Pool(processes=num_processes)
 start_time = time.time()
 pool.map(download_url, urls)
 end_time = time.time()
# Close the pool and wait for all processes to finish
 pool.close()
 pool.join()
 print(f"Multiprocessing download took {end_time-start_time:.2f} seconds")
main()

בדוגמה זו, ריבוי עיבודים מוליד תהליכים מרובים, מה שמאפשר את download_url פונקציה לפעול במקביל.

מתי להשתמש במקביל או מקביליות

הבחירה בין מקביליות ומקבילות תלויה באופי המשימות שלך ובמשאבי החומרה הזמינים.

אתה יכול להשתמש במקביל בעת התמודדות עם משימות הקשורות ל-I/O, כגון קריאה וכתיבה לקבצים או ביצוע בקשות רשת, וכאשר אילוצי זיכרון מהווים דאגה.

השתמש בריבוי עיבוד כאשר יש לך משימות הקשורות למעבד שיכולות להפיק תועלת מקביליות אמיתית וכאשר יש לך בידוד חזק בין משימות, כאשר כישלון של משימה אחת לא אמור להשפיע על אחרות.

נצל את מקביליות ומקביליות

מקביליות ומקביליות הן דרכים יעילות לשיפור ההיענות והביצועים של קוד Python שלך. חשוב להבין את ההבדלים בין המושגים הללו ולבחור את האסטרטגיה היעילה ביותר.

Python מציעה את הכלים והמודולים הדרושים לך כדי להפוך את הקוד שלך ליעיל יותר באמצעות מקביליות או מקבילות, ללא קשר אם אתה עובד עם תהליכים הקשורים ל-CPU או I/O-bound.