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

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

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

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

ישנן ספריות פרופילים רבות ב-Python. כמה מהפופולריים ביותר הם memory_profiler, psutil, Tracemalloc, ו פימפלר. הדרכה זו משתמשת memory_profiler ו psutil.

בזמן psutil הוא אידיאלי להערכת צריכת הזיכרון הכוללת של ביצוע שיטה או פונקציה, memory_profiler נותן מידע מפורט יותר על שימוש בזיכרון, כולל מגמות שימוש קו-לפי ומגמות שימוש ברמה פונקציונלית לאורך זמן.

כדי להתחיל, התקן memory_profiler לתוך הסביבה הוירטואלית Python שלך. זה גם מתקין psutil.

pip התקנת memory_profiler

קבל את הגודל של אובייקט בזיכרון

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

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

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

ה sys.getsizeof השיטה המובנית מועילה כאן:

יְבוּא sys
הדפס(גודל רשימה f": {sys.getsizeof([])} בתים")
הדפס(f"גודל מילון: {sys.getsizeof (dict)} בתים")
הדפס(גודל f"tuple: {sys.getsizeof(())} בתים")
הדפס(גודל f"סט: {sys.getsizeof({})} בתים")

הנה הפלט:

אתה יכול גם להשתמש ב sys.getsizeof שיטה להשוואת גודל הזיכרון של פונקציה מובנית והתאמה אישית.

לדוגמה, השווה את פונקציית האורך המותאם אישית הזו משתמש ב-Python for loop עם המובנה לן פוּנקצִיָה:

יְבוּא sys
defgetLength(ניתן לשחזר):
 לספור = 0
ל אני ב ניתן לחזור על:
 לספור +=1
לַחֲזוֹר לספור
הדפס(f"פונקציית אורך מובנית: {sys.getsizeof (len)} בתים")
הדפס(f"פונקציית אורך מותאם אישית: {sys.getsizeof (getLength)} בתים")

הקוד למעלה נותן את הפלט הבא:

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

מצא את פרופיל הזיכרון של פונקציית Python

אתה יכול לקבל פרופיל זיכרון מפורט יותר של כל שורת קוד של פונקציה באמצעות memory_profiler חֲבִילָה. זה כרוך בהוספת ה @פּרוֹפִיל מעצב לפונקציה או השיטה שלך:

לייבא פנדות
ייבוא ​​numpy
מפרופיל הייבוא ​​של memory_profiler
מחלקה מניפולציה:
 @פּרוֹפִיל
 def manipulateData (עצמי):
 df = פנדות. DataFrame({
 'A' :[0, 3, numpy.nan, 10, 3, numpy.nan], 
 'B': [numpy.nan, "Pandas", numpy.nan, "Pandas", "Python", "JavaScript"], 
 })
 df.fillna (method='bfill', inplace=True)
 df.fillna (method='ffill', inplace=True)
 return str (df)
manip = Manipulate()
print (manip.manipulateData())

הקוד לעיל נותן פרופיל זיכרון מפורט של כל שורת קוד בפונקציה כפי שמוצג:

ה שימוש ב-Mem העמודה מציינת את השימוש בזיכרון עבור שורת קוד מסוימת, בעוד ש- תוֹסֶפֶת העמודה מציגה את התקורה שתרמה כל שורה. ה הִתרַחֲשׁוּת העמודה מגדירה את מספר הפעמים ששורת קוד מקצה או מבטלת זיכרון.

לדוגמה, בפלט לעיל, קו 11 התרחש פעמיים עם תוספת זיכרון של 0.1 MiB (Mebibyte), מה שהגדיל את השימוש בזיכרון ל-55.4 MiB. קווים 19 ו-22 גם תרמו 0.2 MiB ו-0.3 MiB, בהתאמה, סה"כ השימוש בזיכרון ל-55.9 MiB.

מצא את פרופיל הזיכרון של סקריפט Python לפי חותמת זמן

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

mpof הרץ את script_name.py

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

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

אתה יכול גם לקבל עלילה של פרופיל הזיכרון. זה דורש התקנה של matplotlib:

pip להתקין matplotlib

לאחר ההתקנה, הפעל את mprof פקודה כך:

עלילת mpof

להלן הפלט במקרה זה:

הפעל את פרופיל זיכרון הסקריפט בקובץ Python ייעודי

אולי תרצה ליצור פרופיל עבור סקריפטים שונים של Python. אתה יכול לעשות את זה באמצעות מודול Python ייעודי דרך Python's תת-תהליך.

בדרך זו, אתה יכול להפריד את פרופיל הזיכרון שלך מבסיס הקוד שלך ולשמור את פלט הגרף באופן מקומי:

יְבוּא תת-תהליך
subprocess.run([
'מפרוף', 'לָרוּץ', '--כלול-ילדים', 'missing.py'
])
# שמור את פלט העלילה באופן מקומי
subprocess.run(['מפרוף', 'עלילה', '--output=output.jpg'])

כדי להפעיל את פרופיל הזיכרון של הסקריפט, אתה רק צריך להפעיל את קובץ Python המכיל את הקוד לעיל. זה יוצר עלילת פרופיל זיכרון (output.jpg) בספריית הקבצים:

מצא את כמות הזיכרון בשימוש מביצוע פונקציה

אתה יכול למצוא את פרופיל הזיכרון הכולל של שיטה או פונקציה במהלך הביצוע באמצעות ה psutil חֲבִילָה.

למשל, לפרופיל הקודם מניפולציה של Pandas DataFrame שיטה בתוך קובץ Python אחר:

יְבוּא psutil
יְבוּא sys
יְבוּא OS
sys.path.append (sys.path[0] + "/..")
# ייבא את המחלקה המכילה את השיטה שלך
מ קוד כלשהו.חסר יְבוּא לְתַפְעֵל
# הצג את הכיתה
manip = Manipulate()
תהליך = psutil. תהליך (os.getpid())
initial_memory = process.memory_info().rss
# הפעל את שיטת היעד:
manip.manipulateData()
# קבל את מידע הזיכרון לאחר הביצוע
final_memory = process.memory_info().rss
memory_consumed = final_memory - initial_memory
memory_consumed_mb = memory_consumed / (1024 * 1024)
הדפס(f"זיכרון הנצרך על ידי הפונקציה: {memory_consumed_mb:.2ו} MB")

האמור לעיל מעריך את פרופיל הזיכרון הכולל של השיטה במגה-בייט (MB) כפי שמוצג:

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

אם אתה משתמש ב-iPython ב-Jupyter Notebook, אתה יכול לחשב את פרופיל הזיכרון של one-liner באמצעות memory_profiler. אתה רק צריך לטעון memory_profiler בתא אחד. לאחר מכן הוסף את %memit פונקציית קסם לקוד שלך בתאים הבאים; זה מחזיר את שיא הזיכרון של הקוד ואת הגודל המוגדל.

שיטה זו לא עובדת עם סקריפטים רגילים של Python מלבד iPython ב-Jupyter Notebook.

לדוגמה:

אתה יכול גם להשתמש ב %memit פונקציית קסם ב-Jypyter Notebook לפרופיל זיכרון של פונקציה בזמן ריצה:

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

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

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