כיצד להשתמש בשיטת numpy.where() של פייתון

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

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

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

תחביר של Python numpy.where()

הפונקציה מקבלת מערך דומה ל-numpy (לדוגמה, מערך numpy של מספרים שלמים/בוליאניים).

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

לדוגמה, תנאי יכול לקבל את הערך array([[True, True, True]]), שהוא מערך בוליאני דומה ל-numpy. (כבררת מחדל, NumPy תומך רק בערכים נומריים, אך אנו יכולים להמיר אותם ל-bool גם)

לדוגמה, אם תנאי הוא array([[True, True, False]]), והמערך שלנו הוא a = ndarray([[1, 2, 3]]), בהחלטת תנאי על המערך (a[:, תנאי]), נקבל את המערך ndarray([[1 2]]).

import numpy as np

a = np.arange(10)
print(a[a <= 2]) # ילכוד רק אלמנטים קטנים או שווים ל-2 ויתעלם מאחרים

פלט

array([0 1 2])

הערה: התנאי הזה ניתן לייצוג גם כ-a <= 2. זהו הפורמט המומלץ עבור מערך התנאים, מכיוון שכתיבתו כמערך בוליאני היא פרוצדורה מתישה מאוד.

אבל מה קורה אם נרצה לשמור על ממד התוצאה, ולא לאבד אלמנטים מהמערך המקורי שלנו? אפשר להשתמש ב־numpy.where() לכך.

numpy.where(condition [, x, y])

יש לנו שני פרמטרים נוספים, x ו־y. מהם?

בגדול, מה שזה אומר הוא שאם condition נכון עבור איבר מסוים במערך שלנו, המערך החדש יבחר באיברים מ־x.

בנוסף, אם הוא שקר, ייבחרו איברים מ־y.

עם זאת, המערך הסופי שלנו יהיה מערך עם איברים מ־x בכל מקום ש־condition = True, ואיברים מ־y בכל מקום ש־condition = False.

שימו לב שאם גם x וגם y הם אופציונליים, אם תציינו x, עליכם להצהיר גם על y. זה בגלל ש־במקרה זה, צורת המערך המפלט חייבת להיות זהה למערך הקלט.

הערה: הלוגיקה הזו חלה גם על מערכים חד־ממדיים ורב־ממדיים כאחד. בשני המקרים, אנו מסננים בהתבסס על התנאי. כן יש לזכור כי צורת המערכים של x, y ו־condition משודרגת ביחד.

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

שימוש ב-numpy.where() של פייתון

נניח שרוצים לקחת רק איברים חיוביים ממערך numpy ולהגדיר את כל האיברים השליליים ל-0, בואו נכתוב את הקוד באמצעות numpy.where().

1. החלפת איברים עם numpy.where()

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

import numpy as np

# אתחול אקראי של מערך דו-ממדי
a = np.random.randn(2, 3)
print(a)

# b יהיה כל האיברים של a כאשר התנאי מתקיים (כלומר רק איברים חיוביים)
# אחרת, נקבע אותו ל-0
b = np.where(a > 0, a, 0)

print(b)

פלט אפשרי

[[-1.06455975  0.94589166 -1.94987123]
 [-1.72083344 -0.69813711  1.05448464]]
[[0.         0.94589166 0.        ]
 [0.         0.         1.05448464]]

כפי שאתה יכול לראות, רק האיברים החיוביים נשמרו כעת!

2. שימוש ב-numpy.where() עם תנאי בודד

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

import random
import numpy as np

a = np.random.randn(2, 3)
b = np.where(a > 0)
print(b)

אם תנסו כעת להריץ את הקוד לעיל, עם השינוי הזה, תקבלו פלט כמו זה:

(array([0, 1]), array([2, 1]))

אם תסתכלו בקרוב, b הוא כעת tuple של מערכי numpy. וכל מערך הוא המיקום של איבר חיובי. מה זה אומר?

כאשר אנו מספקים רק תנאי, פונקציה זו דומה בעצם ל־np.asarray.nonzero().

בדוגמתנו, np.asarray(a > 0) תחזיר מערך בעל דמיון בוליאני לאחר החלת התנאי, ו־np.nonzero(arr_like) תחזיר את האינדקסים של האיברים השווים לאפס של arr_like. (ראו קישור זה)

לכן, נסתכל כעת על דוגמה פשוטה יותר, שמציגה לנו כמה גמישים אנו יכולים להיות עם numpy!

import numpy as np

a = np.arange(10)

b = np.where(a < 5, a, a * 10)

print(a)
print(b)

פלט

[0 1 2 3 4 5 6 7 8 9]
[ 0  1  2  3  4 50 60 70 80 90]

כאן, התנאי הוא a < 5, שיהיה המערך בדומה ל־numpy [True True True True True False False False False False], x הוא המערך a, ו־y הוא המערך a * 10. לכן, אנו בוחרים מ־a רק אם a < 5, ומ־a * 10 אם a > 5.

לכן, זה מעביר את כל האיברים >= 5, על ידי הכפלה ב־10. זה מה שאנו מקבלים באמת!

שידור עם numpy.where()

אם אנו מספקים את כל המערכים condition, x, ו־y, numpy ישדר אותם יחד.

import numpy as np

a = np.arange(12).reshape(3, 4)

b = np.arange(4).reshape(1, 4)

print(a)
print(b)

# שידור (a < 5, a, ו־b * 10)
# בצורת (3, 4), (3, 4) ו־(1, 4)
c = np.where(a < 5, a, b * 10)

print(c)

פלט

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[0 1 2 3]]
[[ 0  1  2  3]
 [ 4 10 20 30]
 [ 0 10 20 30]]

שוב, כאן הפלט נבחר על פי התנאי, כך שכל האיברים, אך כאן, b משודר לצורת a. (אחד ממימדיו יש רק איבר אחד, לכן לא יהיו שגיאות בעת השידור)

לכן, b כעת יהפוך להיות [[0 1 2 3] [0 1 2 3] [0 1 2 3]], וכעת, נוכל לבחור איברים גם ממערך השידור הזה.

לכן צורת הפלט תהיה זהה לצורת a.

מסקנה

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

הפניות

• תיעוד SciPy על פונקציית numpy.where() ב-Python