`numpy` — פעולות מערך תואמות numpy¶

תת-המודול numpy של ulab מספק API תואם numpy הבנוי סביב טיפוס המערך הרב-ממדי ndarray. הוא מממש תת-קבוצה נבחרת של numpy של CPython: בניית מערכים, חישובים אלמנט-אחר-אלמנט, רדוקציות וסטטיסטיקה, אלגברה לינארית, התמרות FFT, יצירת מספרים אקראיים, התאמת פולינומים, וקלט/פלט בסיסי.

מקובל לייבא את תת-המודול בתור np

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

כל ארגומנט dtype הוא אחד מקבועי המספרים השלמים החשופים ברמת המודול: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (ברירת המחדל), ו-(כאשר תמיכה במספרים מרוכבים מהודרת) numpy.complex. טיפוס התוצאה ndarray מתייחס ל-numpy.ndarray.

תת-מודולים¶

מחלקה `ndarray` — המערך הרב-ממדי¶

ה-ndarray הוא המכל הרב-ממדי, מודע ל-dtype, שנמצא בליבת numpy / ulab. הנתונים נשמרים בבלוק רציף שפרשנותו מתוארת על ידי כותרת קטנה (dtype, shape, strides, ndim, itemsize). פעולות רבות – reshape, transpose, פריסה – רק מתאימות כותרת זו ולכן הן זולות מאוד; מתודות שמקצות אחסון חדש (copy, flatten, רוב פעולות החשבון) מחזירות מערך צפוף חדש.

אותו טיפוס נגיש בתור ulab.ndarray, numpy.ndarray, ו-(בתוך עמוד זה) פשוט ndarray.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)¶

יצירת ndarray חדש.

פרמטרים:

values – נתוני מקור. או ndarray אחר (שמועתק עומק, עם המרת טיפוס אם dtype שונה) או כל איטרבל של MicroPython. איטרבלים מקוננים מייצרים מערכים רב-ממדיים; כל האיטרבלים הפנימיים חייבים להיות באותו אורך אחרת מועלה ValueError.
dtype – טיפוס האלמנטים של המערך החדש. אחד ממספרי קוד הטיפוס החשופים על ידי numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float, ו– כאשר נתמך – numpy.complex), או מופע dtype. ברירת המחדל היא numpy.float.

פונקציית המפעל numpy.array היא הדרך המקובלת ליצירת ndarray; היא מעבירה את הבקשה לבנאי זה.

byteswap(*, inplace: bool = False) → ndarray¶

החלפת סדר הבתים של כל אלמנט. עבור מערכי uint16, int16, float ו-complex פעולה זו הופכת את סדר הבתים בכל אלמנט, מה שמועיל בעת צריכת נתונים מהתקנים היקפיים שסדר הבתים (endianness) שלהם אינו תואם לזה של המיקרו-בקר. עבור dtypes בני בית יחיד (bool, uint8, int8) זוהי פעולה ריקה שמחזירה תצוגה או עותק.

אם inplace הוא False (ברירת המחדל) מוחזר ndarray חדש והמקור נותר ללא שינוי. אם inplace הוא True הבתים של self מוחלפים במקום ומוחזרת תצוגה של self.

copy() → ndarray¶: החזרת עותק עומק צפוף חדש של המערך. העותק מחזיק בנתונים משלו; שינויים בו אינם משפיעים על המקור.

flatten(*, order: str = 'C') → ndarray¶

החזרת עותק חד-ממדי חדש של המערך.

פרמטרים:: order – 'C' (ברירת המחדל) עובר על הנתונים בסדר C (הציר האחרון משתנה הכי מהר); 'F' עובר עליהם בסדר Fortran (הציר הראשון משתנה הכי מהר).

reshape(shape: int | tuple[int, ...]) → ndarray¶: החזרת תצוגה של המערך עם צורה חדשה. מספר האלמנטים הכולל חייב להישאר ללא שינוי אחרת מועלה ValueError. זמין רק כאשר ULAB_MAX_DIMS > 1. שקול להשמה ל-shape.

sort(*, axis: int | None = -1) → None¶

מיון המערך במקום.

פרמטרים:: axis – הציר שלאורכו ממיינים. -1 (ברירת המחדל) ממיין לאורך הציר האחרון; None משטח תחילה את המערך ואז ממיין.

tobytes() → bytearray¶: החזרת bytearray המהווה כינוי (alias) לחוצץ הנתונים הבסיסי של המערך. כתיבות דרך ה-bytearray המוחזר משנות את המערך במקום. מעלה ValueError אם המערך אינו צפוף (למשל תצוגה חתוכה).

tolist() → list¶: החזרת תוכן המערך כ-list של Python (אולי מקונן). עומק הקינון שווה ל-ndim.

transpose() → ndarray¶: החזרת השחלוף (transpose) של המערך (הצירים הפוכים). עבור מערכים חד-ממדיים פעולה זו מחזירה self. זמין רק כאשר ULAB_MAX_DIMS > 1. התכונה T היא קיצור למתודה זו.

dtype: dtype | int¶: טיפוס הנתונים של אלמנטי המערך. מחזיר מופע dtype כאשר הקושחה נבנתה עם ULAB_HAS_DTYPE_OBJECT מאופשר, אחרת את קוד הטיפוס הבסיסי בן התו היחיד כמספר שלם.

flat: flatiter¶: איטרטור שטוח שמניב כל אלמנט של המערך בסדר C. בניגוד ל-flatten(), איטרציה על flat אינה מקצה מערך חדש.

itemsize: int¶: גודל בבתים של אלמנט מערך יחיד, נגזר מ-dtype.

ndim: int¶: מספר ממדי המערך (אורכו של shape).

shape: tuple[int, ...]¶: אורכי המערך לאורך כל ציר. השמה של tuple ל-shape משנה את צורת המערך במקום (שקול ל-reshape()).

size: int¶: מספר האלמנטים הכולל במערך (מכפלת shape).

strides: tuple[int, ...]¶: מספר הבתים שיש לדלג בזיכרון לאורך כל ציר כדי להגיע לאלמנט הבא לאורך אותו ציר.

T: ndarray¶: השחלוף (transpose) של המערך; שקול ל-transpose().

real: ndarray¶: החלק הממשי של מערך מרוכב, מוחזר כ-ndarray מסוג float. עבור מערכים ממשיים זהו עותק של self עם אותו dtype. זמין רק כאשר הקושחה נבנתה עם תמיכה במספרים מרוכבים.

imag: ndarray¶: החלק המדומה של מערך מרוכב, מוחזר כ-ndarray מסוג float. עבור מערכים ממשיים זהו מערך של אפסים עם אותו dtype כמו self. זמין רק כאשר הקושחה נבנתה עם תמיכה במספרים מרוכבים.

אופרטורים נתמכים¶

מופעי ndarray תומכים באופרטורים הבאים. אופרטורים בינאריים משדרים (broadcast) את האופרנדים שלהם לפי כללי השידור הסטנדרטיים של numpy ועוקבים אחר כללי ההמרה כלפי מעלה של numpy (למשל uint8 + int8 => int16, uint16 + int16 => float); פעולות שמערבות אופרנד מרוכב מייצרות תוצאה מרוכבת.

חשבון (בינארי): +, -, *, /, //, %, **. אופרנדים משוקפים (צד ימין) והווריאנטים במקום +=, -=, *=, /=, %=, **= נתמכים גם הם. הצורות של ndarray-עם-ndarray ו-ndarray-עם-סקלר מתקבלות שתיהן. חלוקה שלמה (//) ואופרטור המודולו (%) אינם ממומשים עבור מערכי complex.

השוואה: ==, !=, <, <=, >, >=. כל אחד מחזיר ndarray בוליאני בצורת השידור.

ביטוויס (מערכי מספרים שלמים בלבד): &, |, ^. החלת אלה על מערך float או complex מעלה TypeError.

אונרי: + (מחזיר עותק), - (שלילה; עבור dtypes ללא סימן הערכים גולשים מודולו \(2^N\)), abs() (ערך מוחלט אלמנט-אחר-אלמנט; עבור dtypes ללא סימן מחזיר עותק ללא חישוב), ~ (היפוך ביטוויס, dtypes שלמים בלבד), len() (מחזיר את אורך הציר הראשון).

אינדוקס ופריסה: a[i], a[i, j, ...], a[start:stop:step], אינדוקס במסכה בוליאנית (a[mask]) ואינדוקס במערך שלמים (fancy) – כולם נתמכים הן בקריאה והן בכתיבה.

איטרציה: איטרציה על ndarray מניבה תת-מערכים לאורך הציר הראשון (אלמנט אחד בכל פעם עבור מערכים חד-ממדיים). השתמשו ב-flat כדי לבצע איטרציה על כל אלמנט סקלרי ללא תלות בממדיות.

אופרטור הכפל-מטריצות @ אינו ממומש; השתמשו ב-numpy.dot (np.dot(a, b)) במקום.

אופרטורי ההסטה (<<, >>) אינם ממומשים ברמת האופרטור. השתמשו ב-numpy.left_shift וב-numpy.right_shift להסטות שלמים אלמנט-אחר-אלמנט.

בניית מערכים¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: בניית ndarray חדש מאיטרבל מקונן של מספרים. בנאי חלופי שקול עבור numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: החזרת ערכים במרווחים שווים על פני הקטע החצי-פתוח [start, stop). אם ניתן רק ארגומנט מיקומי אחד, הוא מטופל כ-stop עם start = 0. אם dtype מושמט, הוא מוסק מהקלטים (שלם אם כל start, stop, step הם שלמים ובטווח).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: אם a הוא כבר ndarray שה-dtype שלו תואם ל-dtype (או dtype הוא None), החזר את a ללא שינוי; אחרת צור מערך חדש (עם המרת ה-dtype המבוקשת כאשר ניתנה). איטרבלים מומרים כמו ב-numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: צירוף רצף של ndarray לאורך axis קיים. כל מערכי הקלט חייבים לחלוק את אותו dtype, ndim, וצורה בכל ציר מלבד axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: עבור a דו-ממדי, החזרת מערך חד-ממדי המכיל את האלכסון ה-k-י. עבור a חד-ממדי, החזרת מערך ריבועי דו-ממדי עם a ממוקם על האלכסון ה-k-י. k יכול להיות חיובי (מעל האלכסון הראשי) או שלילי (מתחתיו).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: כינוי ל-zeros; מחזיר מערך מלא באפסים בצורה shape ו-dtype dtype. (ulab אינו משאיר את החוצץ לא מאותחל.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: החזרת מערך דו-ממדי N x M (ריבועי N x N אם M הוא None) עם אחדות על האלכסון ה-k-י ואפסים במקומות אחרים.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: פירוש אובייקט בעל פרוטוקול חוצץ כ-ndarray חד-ממדי מסוג dtype. count הוא מספר הפריטים לקריאה (-1 קורא את כל הפריטים הזמינים); offset מדלג על מספר זה של בתים בתחילת החוצץ.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: החזרת מערך חדש בצורה shape ו-dtype dtype שכל אלמנט בו מוגדר ל-fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: החזרת num דגימות במרווחים שווים על פני הקטע הסגור [start, stop] (או חצי-פתוח אם endpoint הוא False). כאשר retstep הוא True, החזרת tuple (samples, step). start/stop מרוכבים מייצרים מערך מרוכב (כאשר תמיכה במספרים מרוכבים מאופשרת).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: החזרת num דגימות במרווחים שווים על סקאלה לוגריתמית: התוצאה מתחילה ב-base ** start ומסתיימת ב-base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: החזרת tuple של מטריצות קואורדינטות מרצף של מערכי קואורדינטות חד-ממדיים. עם indexing 'xy' (ברירת המחדל) שני הקלטים הראשונים מטופלים כקואורדינטות קרטזיות וצירי הפלט שלהם מוחלפים; עם 'ij' נעשה שימוש באינדוקס בסגנון מטריצה. המימוש תואם למקבילה ב-NumPy עם copy=True ו-sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: החזרת מערך חדש בצורה shape ו-dtype dtype מלא באחדות.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: החזרת מערך חדש בצורה shape ו-dtype dtype מלא באפסים.

בדיקה / הדפסה¶

numpy.get_printoptions() → dict¶: החזרת אפשרויות הדפסת המערך הנוכחיות כ-dict עם המפתחות threshold ו-edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: הגדרת אפשרויות הדפסת מערך. threshold הוא המספר המרבי של אלמנטי מערך המודפסים במלואם; edgeitems הוא מספר הפריטים המוצגים בכל קצה של ציר כאשר המערך מתומצת.

numpy.ndinfo(array: ndarray) → None¶: הדפסת מידע אבחוני (צורה, strides, dtype, itemsize, …) על array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: החזרת מספר האלמנטים של a לאורך axis; אם axis הוא None, החזרת מספר האלמנטים הכולל (מכפלת ndarray.shape).

השוואה¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: קיטום (clip) של ערכי a כך ש-a_min <= result <= a_max. שקול ל-maximum(a_min, minimum(a, a_max)); השידור עוקב אחר אותם כללים כמו minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 == x2 אלמנט-אחר-אלמנט; מחזיר ndarray בוליאני (או סקלר bool אם שני הקלטים סקלרים). מסופק לצורך ניידות – אופרטור ה-== על מערכים נותן את אותה תוצאה.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 != x2 אלמנט-אחר-אלמנט; המקבילה הבוליאנית ל-equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: החזרת מערך בוליאני (או סקלר) שהוא True היכן שהקלט סופי. קלטים שלמים תמיד סופיים.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: החזרת מערך בוליאני (או סקלר) שהוא True היכן שהקלט אינסופי. קלטים שלמים לעולם אינם אינסופיים.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: מקסימום אלמנט-אחר-אלמנט של שני מערכים / סקלרים. הארגומנטים משודרים יחד; אם ה-dtypes שונים, הפלט מומר כלפי מעלה.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: מינימום אלמנט-אחר-אלמנט של שני מערכים / סקלרים; מקבילה ל-maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: החזרת tuple של ndarray, אחד לכל ממד של a, המכיל את האינדקסים של האלמנטים השונים מאפס של a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: החזרת ndarray שאלמנטיו מגיעים מ-x היכן ש-condition אמיתי, ומ-y אחרת. שלושת הקלטים משודרים יחד; ה-dtype של הפלט הוא ההמרה כלפי מעלה של x ו-y.

רדוקציות מספריות¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: בדיקה האם כל האלמנטים לאורך axis מוערכים כ-True. עם axis=None (ברירת המחדל) המערך המשוטח נבדק ומוחזר bool יחיד.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: בדיקה האם אלמנט כלשהו לאורך axis מוערך כ-True. עם axis=None המערך המשוטח נבדק.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: החזרת האינדקס של האלמנט המקסימלי לאורך axis. עם axis=None המערך משוטח ומוחזר מספר שלם יחיד.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: החזרת האינדקס של האלמנט המינימלי לאורך axis. עם axis=None המערך משוטח ומוחזר מספר שלם יחיד.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: החזרת ndarray של אינדקסים מסוג מספר שלם ללא סימן שערכיו ממיינים את a בסדר עולה לאורך axis. ה-dtype של הפלט הוא uint16, ולכן אף ציר לא יכול לעלות על 65535 אלמנטים. axis=None אינו נתמך.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: החזרת המכפלה הווקטורית של שני מערכים חד-ממדיים באורך 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: החזרת ההפרש הקדמי הבדיד ה-n-י של a לאורך axis. n חייב להיות בטווח 0..9 (סטנסיל הגזירה נשמר ב-int8); אורך axis מתכווץ ב-n. מילות המפתח prepend ו-append של numpy אינן ממומשות.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: החזרת מערך חדש שבו סדר האלמנטים הפוך לאורך axis; עם axis=None המערך הפוך לאורך כל ציר.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: החזרת האלמנט המקסימלי לאורך axis. עם axis=None (ברירת המחדל) המערך המשוטח מצומצם לסקלר. מילת המפתח out של numpy אינה ממומשת.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: החזרת האלמנט המינימלי לאורך axis; מקבילה ל-max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: החזרת הממוצע החשבוני לאורך axis. עם axis=None (ברירת המחדל) הממוצע של המערך המשוטח מוחזר כ-float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: החזרת החציון לאורך axis. עם axis=None המערך משוטח תחילה. ה-dtype של הפלט הוא תמיד float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: החזרת a עם אלמנטיו מסובבים (מוסטים מחזורית) ב-shift מיקומים. עם axis=None (ברירת המחדל) המערך משוטח תחילה. הסטות שליליות מסובבות בכיוון ההפוך.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: החזרת עותק ממוין של a לאורך axis באמצעות מיון ערמה (heap sort). עם axis=None המערך משוטח תחילה. מילות המפתח kind ו-order של numpy אינן ממומשות.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: החזרת סטיית התקן לאורך axis. ddof הוא דרגות החופש דלתא – המחלק הנמצא בשימוש הוא N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: החזרת הסכום לאורך axis. עם axis=None הסך הכולל של המערך המשוטח מוחזר כסקלר.

סטטיסטיקה¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: ספירת מספר המופעים של כל ערך במערך המספרים השלמים האי-שליליים החד-ממדי x. ה-dtype של x חייב להיות uint8 או uint16. אם weights ניתן, כל ערך של x תורם את המשקל התואם שלו במקום 1 והפלט הוא מסוג dtype float; אחרת הפלט הוא מסוג dtype uint16. אם minlength ניתן, למערך הפלט יש לפחות מספר זה של אלמנטים (ערכים נוספים הם אפס).

numpy.trace(m: ndarray) → int | float¶: החזרת סכום אלמנטי האלכסון של המטריצה הריבועית m. טיפוס ההחזרה עוקב אחר ה-dtype של m (מערכי שלמים מייצרים שלם, מערכי float מייצרים float).

התמרה¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: החזרת פרוסות של a שנבחרו לאורך axis על ידי ה-condition הבוליאני. עם axis=None נעשה שימוש במערך המשוטח.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: החזרת עותק של a כשהערכים ב-indices מוסרים לאורך axis. עם axis=None המערך משוטח תחילה. אינדקסים שליליים נספרים מהסוף של axis; indices ממוין באופן פנימי לפני המחיקה.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: החזרת המכפלה הסקלרית (dot) של שני מערכים. עבור שני מערכים חד-ממדיים זוהי המכפלה הפנימית (סקלר float). עבור מערכים דו-ממדיים זהו כפל מטריצות; הממדים הפנימיים חייבים להתאים. התוצאה היא תמיד מסוג dtype float.

קירוב¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: אינטרפולציה לינארית חד-ממדית. xp חייב להיות מערך חד-ממדי עולה מונוטונית של ערכים בלתי-תלויים; fp מכיל את הערכים התלויים המתאימים; x הם הנקודות שבהן מוערך האינטרפולנט. left ו-right דורסים את הערך המוחזר עבור x < xp[0] ועבור x > xp[-1] בהתאמה (ברירות מחדל: fp[0] ו-fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: אינטגרציה של y באמצעות כלל הטרפז המורכב. אם x ניתן הוא מספק את מיקומי הדגימה המתאימים ל-y; אחרת נעשה שימוש במרווח dx. y (ו-x) חייבים להיות חד-ממדיים.

בחירה¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: לקיחת אלמנטים מ-a באינדקסים הנתונים indices לאורך axis. עם axis=None נעשה שימוש במערך המשוטח. mode בוחר את ההתנהגות מחוץ לתחום: "raise" (ברירת מחדל – מעלה ValueError), "wrap" (מודולו אורך הציר), או "clip" (קיטום לטווח התקף; אינדקסים שליליים אינם מותרים). אם out ניתן התוצאה נכתבת לתוכו.

ביטוויס¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: AND ביטוויס אלמנט-אחר-אלמנט של שני מערכי שלמים; שידור נתמך. dtype שאינו שלם מעלה חריגה.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: OR ביטוויס אלמנט-אחר-אלמנט של שני מערכי שלמים.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: XOR ביטוויס אלמנט-אחר-אלמנט של שני מערכי שלמים.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: הסטה ביטוויס אלמנט-אחר-אלמנט של x1 שמאלה ב-x2 ביטים; שני המערכים חייבים להיות בעלי dtype שלם.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: הסטה ביטוויס אלמנט-אחר-אלמנט של x1 ימינה ב-x2 ביטים; שני המערכים חייבים להיות בעלי dtype שלם.

סינון¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: החזרת הקונבולוציה הלינארית הבדידה של שני מערכים חד-ממדיים. רק מצב "full" נתמך; מילת המפתח mode של numpy אינה מתקבלת (ניתן להשיג מצבים אחרים על ידי פריסת התוצאה המלאה). אורך הפלט הוא len(a) + len(v) - 1.

פולינום¶

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray¶

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: התאמת פולינום בדרגה deg לנקודות הנתונים (x, y) בשיטת הריבועים הפחותים והחזרת מקדמי הפולינום (הדרגה הגבוהה תחילה). אם x מושמט, נעשה שימוש ב-range(len(y)). מעלה ValueError אם האורכים של x ו-y שונים.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: הערכת הפולינום שמקדמיו הם p (הדרגה הגבוהה תחילה) ב-x. אם x הוא סקלר מוחזר float, אחרת ndarray.

קלט/פלט¶

numpy.load(file: str) → ndarray¶: קריאת מערך שנכתב קודם לכן עם save מתוך file (פורמט .npy הבלתי-תלוי-בפלטפורמה של numpy). סדר הבתים (endianness) מומר תוך כדי תנועה אם סדר הבתים של הקובץ שונה מזה של המארח.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray¶: קריאת נתונים מספריים מתוך file טקסטואלי והחזרתם כ-ndarray. delimiter מוגדר כברירת מחדל לרווח לבן; comments הוא סמן ההערה של שורה; max_rows מגביל את מספר שורות הנתונים הנקראות (-1 עבור הכל); usecols בוחר עמודות לפי אינדקס; skiprows מדלג על מספר זה של שורות מובילות. אם dtype אינו float, הערכים מומרים באמצעות עיגול.

numpy.save(file: str, a: ndarray) → None¶: שמירת a אל file בפורמט .npy הבלתי-תלוי-בפלטפורמה של numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: כתיבת a אל file כטקסט. delimiter מפריד בין ערכים בתוך שורה; header ו-footer, אם ניתנו, נכתבים לפני/אחרי הנתונים, כל אחד עם קידומת של comments. הערכים נכתבים כנקודה צפה.

עוזרי מספרים מרוכבים¶

פונקציות אלה זמינות רק כאשר ulab הודר עם תמיכה במספרים מרוכבים (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: החזרת החלק הממשי של val. עבור קלט עם dtype ממשי, מחזיר עותק שמשמר את ה-dtype; עבור קלט מרוכב, מחזיר ndarray מסוג float.

numpy.imag(val: ndarray) → ndarray¶: החזרת החלק המדומה של val. עבור קלט עם dtype ממשי, מחזיר מערך של אפסים עם אותו dtype; עבור קלט מרוכב, מחזיר ndarray מסוג float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: החזרת הצמוד המרוכב של val. קלטים בעלי ערך ממשי מוחזרים ללא שינוי.

numpy.sort_complex(a: ndarray) → ndarray¶: מיון המערך החד-ממדי a תחילה לפי חלק ממשי, ואז לפי חלק מדומה. התוצאה היא תמיד מסוג dtype מרוכב, גם אם a היה בעל ערך ממשי.

פונקציות אוניברסליות¶

פונקציות מתמטיות אלמנט-אחר-אלמנט. כל אחת מקבלת סקלר או ndarray ומחזירה תוצאה בצורה תואמת (סקלר float עבור קלט סקלרי, ndarray עבור קלט מערך). כאשר נקראת עם ndarray, התוצאה היא ndarray חדש בנקודה צפה; ניתן להעביר מילת מפתח אופציונלית out כדי לכתוב את התוצאה לתוך ndarray מסוג float שהוקצה מראש באותו גודל.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: חישוב הקוסינוס ההפוך (ארקוס קוסינוס) של כל אלמנט של x; התוצאה ברדיאנים.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: חישוב הקוסינוס ההיפרבולי ההפוך של כל אלמנט של x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: חישוב הטנגנס ההפוך הדו-ארגומנטי atan2(y, x) אלמנט-אחר-אלמנט; תומך בשידור בין שני הקלטים.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: עיגול אלמנטי ה-ndarray x למספר ה-decimals הנתון; הארגומנט הראשון חייב להיות ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: חישוב הסינוס ההפוך (ארקוס סינוס) של כל אלמנט של x; התוצאה ברדיאנים.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: חישוב הסינוס ההיפרבולי ההפוך של כל אלמנט של x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: חישוב הטנגנס ההפוך (ארקוס טנגנס) של כל אלמנט של x; התוצאה ברדיאנים.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: חישוב הטנגנס ההיפרבולי ההפוך של כל אלמנט של x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: חישוב התקרה (המספר השלם הקטן ביותר שאינו קטן מהערך) של כל אלמנט של x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: חישוב הקוסינוס של כל אלמנט של x (ברדיאנים).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: חישוב הקוסינוס ההיפרבולי של כל אלמנט של x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: המרת כל אלמנט של x מרדיאנים למעלות.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: חישוב המעריך e**x של כל אלמנט של x; עשוי להחזיר ndarray מרוכב כאשר ניתן קלט מרוכב (אם תמיכה במספרים מרוכבים מאופשרת).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: חישוב exp(x) - 1 של כל אלמנט של x עם דיוק משופר בקרבת אפס.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: חישוב הרצפה (המספר השלם הגדול ביותר שאינו גדול מהערך) של כל אלמנט של x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: חישוב הלוגריתם הטבעי של כל אלמנט של x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: חישוב הלוגריתם בבסיס 10 של כל אלמנט של x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: חישוב הלוגריתם בבסיס 2 של כל אלמנט של x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: המרת כל אלמנט של x ממעלות לרדיאנים.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: חישוב הסינוס של כל אלמנט של x (ברדיאנים).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: חישוב פונקציית ה-sinc המנורמלת sin(pi*x) / (pi*x) של כל אלמנט של x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: חישוב הסינוס ההיפרבולי של כל אלמנט של x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: חישוב השורש הריבועי של כל אלמנט של x; העבירו dtype=numpy.complex כדי לקבל תוצאות מרוכבות עבור קלטים ממשיים שליליים (אם תמיכה במספרים מרוכבים מאופשרת).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: חישוב הטנגנס של כל אלמנט של x (ברדיאנים).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: חישוב הטנגנס ההיפרבולי של כל אלמנט של x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: החזרת אובייקט נקרא (callable) שמחיל את פונקציית Python f אלמנט-אחר-אלמנט על סקלר, איטרבל, או ndarray; otypes בוחר את ה-dtype של הפלט (ברירת מחדל float).

קבועים¶

numpy.e: float¶: מספר אוילר \(e \approx 2.71828\).

numpy.pi: float¶: \(\pi \approx 3.14159\).

numpy.inf: float¶: אינסוף חיובי של נקודה צפה לפי IEEE-754.

numpy.nan: float¶: ”לא מספר“ (not a number) של נקודה צפה לפי IEEE-754.

numpy.bool: int¶: קוד dtype עבור מערכים בוליאניים (נשמרים כ-uint8).

numpy.uint8: int¶: קוד dtype עבור מערכי מספרים שלמים בני 8 ביטים ללא סימן.

numpy.int8: int¶: קוד dtype עבור מערכי מספרים שלמים בני 8 ביטים עם סימן.

numpy.uint16: int¶: קוד dtype עבור מערכי מספרים שלמים בני 16 ביטים ללא סימן.

numpy.int16: int¶: קוד dtype עבור מערכי מספרים שלמים בני 16 ביטים עם סימן.

numpy.float: int¶: קוד dtype עבור מערכי נקודה צפה בני 32 ביטים.

numpy — פעולות מערך תואמות numpy¶