מה זה שידור NumPy?
בעת ביצוע פעולות אריתמטיות על מערכים בצורות שונות, NumPy מתייחס לזה כשידור. פעולות מערך אלה מבוצעות לעתים קרובות על האלמנטים המתאימים. אם לשני מערכים יש אותה צורה, אפשר לעשות עליהם בקלות. למרות שמושג זה שימושי, שידור לא תמיד מומלץ מכיוון שהוא עלול לגרום לשימוש לא יעיל בזיכרון שמאט את החישוב. פעולות NumPy מבוצעות לרוב על צמדי מערכים המחולקים אלמנט אחר אלמנט.
כללי השידור
יש להקפיד על סדרה מסוימת של הנחיות בעת השידור. אלה מתוארים להלן:
- חשוב להוסיף את צורת מערך הדרגה הנמוכה יותר עם 1s עד ששתי הצורות של המערכים חולקות את אותו אורך אם לשני מערכים אין דרגה זהה.
- שני מערכים נחשבים לתואמים אם יש להם אותו גודל ממד או אם לאחד מהם גודל הממד מוגדר ל-1.
- ניתן לשדר את המערכים יחד רק אם הגדלים והמידות שלהם תואמים.
- לאחר השלמת השידור, כל מערך פועל כאילו צורתו מתאימה לזו של האלמנט הגדול ביותר בצורות של שני מערכי הקלט.
- אחד המערכים מתנהג כאילו הוא שוכפל עם הממד הזה אם למערך השני יש ממד גדול מ-1 ולמערך הראשון יש ממד של 1.
כעת, בואו נדון בכמה דוגמאות ליישום מושג השידור.
דוגמה 1:
בזוגות של מערכים, פעולות NumPy מבוצעות בדרך כלל אלמנט אחר אלמנט. שני המערכים חייבים, בתרחיש הפשוט ביותר, להיות בעלי אותה צורה, כמו בדוגמה שלהלן:
יְבוּא רדום
one_arr = רדום. מַעֲרָך ( [ 2.0 , 3.0 , 1.0 ] )
two_arr = רדום. מַעֲרָך ( [ 3.0 , 3.0 , 3.0 ] )
הדפס ( one_arr * two_arr )
כפי שניתן לראות מהקוד שלמעלה, יש לנו שני מערכים: 'one_arr' ו-'two_ arr'. לכל אחד מהם סט ערכים נפרד. הערכים ב-'one_arr' הם [2.0,3.0,1.0] ו-'two _arr' הם [3.0,3.0,3.0]. לאחר מכן תוכל לראות שהתוצאה של חישוב המכפלה של שני מערכים אלה היא כדלקמן:
כאשר טפסי המערכים עומדים בדרישות מסוימות, כלל השידור של NumPy מוריד את ההגבלה הזו. כאשר מצטרפים מערך וערך סקלרי במבצע, השידור מודגם בצורה הבסיסית ביותר שלו. כפי שאתה יכול לראות, 3 כלול במשתנה בשם 'two_arr'.
יְבוּא רדוםone_arr = רדום. מַעֲרָך ( [ 2.0 , 3.0 , 1.0 ] )
two_arr = 3.0
הדפס ( one_arr * two_arr )
הקוד לעיל מייצר את התוצאה הבאה.
בדוגמה הקודמת, שבה 'two_arr' היה מערך, התוצאה שווה ערך. אנו עשויים לדמיין את 'two_arr' הסקלרי מתרחב במהלך התהליך האריתמטי למערך בעל צורה זהה ל-'one _arr'. המערך 'two_arr' מכיל אלמנטים חדשים שהם רק כפילויות של הסקלר הראשון. השוואת המתיחה היא היפותטית בלבד. כדי להפוך את פעולות השידור לזיכרון וחסכוניות מבחינה חישובית ככל האפשר, NumPy חכמה מספיק כדי להשתמש בערך הסקלרי המקורי במקום לייצר עותקים.
דוגמה 2:
הנה עוד תוכנית Python פשוטה שמבצעת שידור. שוב נוצרים שני מערכים המכילים ערכים שונים. יש צורך לעצב מחדש את 'first_arr' לוקטור עמודה עם צורה של 3×1 כדי לחשב מכפלה חיצונית. לאחר מכן, השידור מתבצע כנגד 'second_arr' כדי לספק תוצאה בגודל 3×2, המכונה המכפלה החיצונית של 'first_arr' ו-'second_arr'. שידור ל-2×3 אפשרי מכיוון ש'result_arr' הוא בעל הצורה 2 ×3 וכן הצורה (3,).
לאחר ביצוע כל השלבים שהוזכרו לעיל, יש לכלול וקטור בכל עמודה של המטריצות שהן 'result_arr' ו-'second_arr.' למימדים של 2×3 ו-(2, ). טרנספוזיציה של 'result_arr' תניב צורה של 3×2, אשר לאחר מכן ניתן לשדר כנגד 'second_arr' כדי לקבל את אותה צורה. בדרך כלל, העברה זו מניבה מוצר סופי בצורה 2×3.
יְבוּא רדוםfirst_arr = רדום. מַעֲרָך ( [ 12 , 24 , 14 ] )
second_arr = רדום. מַעֲרָך ( [ חֲמֵשׁ עֶשׂרֵה , 22 ] )
הדפס ( רדום. שִׁנוּי צוּרָה ( first_arr , ( 3 , 1 ) ) *שני_ערר )
result_arr = רדום. מַעֲרָך ( [ [ 12 , 22 , 31 ] , [ חֲמֵשׁ עֶשׂרֵה , 22 , ארבע חמש ] ] )
הדפס ( result_arr + first_arr )
הדפס ( ( result_arr. ט + second_arr ) . ט )
הדפס ( result_arr + numpy. שִׁנוּי צוּרָה ( second_arr , ( שתיים , 1 ) ) )
הדפס ( result_arr * שתיים )
אתה יכול לראות את הפלט למטה.
דוגמה 3:
ניתן לשדר מערך תלת מימדי באמצעות תוכנית Python הבאה. בדוגמה זו נוצרו שני מערכים בשם 'first_arr' ו-'second_arr'. המערך 'first_arr' מכיל ערכי [4,13,26,12] ו-'second_arr' מכיל ערכי [32,67,45,17]. 2 המימדים של המערך הראשוני עושים את ההבדל. סכום המערך הראשון והשני יוצג להלן לאחר ביצוע הקוד. אתה יכול לראות שיש לנו שלוש הצהרות הדפסה בקוד, שכל אחת מהן מציגה את הטקסט 'מערך ראשון:', 'מערך שני' ו'מערך שלישי:' בתורם. לאחר מכן מוצג הסכום של שני המערכים החדשים שנוצרו.
יְבוּא רדוםfirst_arr = רדום. מַעֲרָך ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , ארבע חמש , 17 ] ] )
second_arr = רדום. מַעֲרָך ( [ 24 , ארבע חמש , 66 , 87 ] )
הדפס ( ' \n מערך ראשון: ' )
הדפס ( first_arr )
הדפס ( ' \n מערך שני: ' )
הדפס ( second_arr )
הדפס ( ' \n סכום המערך הראשון והשני: ' )
sum_result = first_arr + second_arr ;
הדפס ( sum_result )
הנה צילום מסך הפלט של הקוד הנתון.
דוגמה 4:
תוכנית Python האחרונה שמשדרת מערך תלת מימדי ניתנת כאן. שני מערכים מצוינים בתוכנית זו, לראשון שבהם יש שלושה מימדים. סכום המערך הראשון והשני יוצג כפי שמוצג לעיל לאחר ביצוע הקוד. למרות שהערכים במערכים אלה משתנים, הקוד הנותר זהה לזה שמשתמשים בתוכנית לדוגמה שלמעלה.
יְבוּא רדוםfirst_arr = רדום. מַעֲרָך ( [ [ 12 , ארבע חמש , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ חמישים , 40 , 18 , 26 ] ] )
second_arr = רדום. מַעֲרָך ( [ 12 , 44 , 22 , 12 ] )
הדפס ( ' \n מערך ראשון: ' )
הדפס ( first_arr )
הדפס ( ' \n מערך שני: ' )
הדפס ( second_arr )
הדפס ( ' \n סכום המערך הראשון והשני: ' )
sum_result = first_arr + second_arr ;
הדפס ( sum_result )
ניתן לראות באיור למטה שמוצג מערך תלת מימדי מהמערך הראשון, ואחריו מערך דו מימדי מהמערך השני והתוצאה של שני אלה תוך שימוש בעקרון השידור.
סיכום
מאמר זה דן בשידור, מושג חיוני לפייתון. ב-NumPy, המונח 'שידור' מתייחס ליכולת לטפל במערכים בצורות שונות תוך ביצוע פעולות אריתמטיות המבוצעות לעתים קרובות. הנושא הנ'ל כוסה ביסודיות במגוון דוגמאות. מאמר זה השתמש בתוכניות לדוגמה שהוזכרו כדי להדגים כיצד לשדר במערכים 1-D, 2-D ו-3-D, בהתאמה. אתה יכול לנסות להפעיל את הדוגמאות האלה במערכת שלך ולהציג את התוצאות כדי להבין טוב יותר איך הכל פועל באופן כללי.