`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 (ברירת המחדל). סוג התוצאה 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), או מופע של dtype. ברירת המחדל היא numpy.float.

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

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

מחליף את סדר הבייטים של כל איבר. עבור מערכי uint16, int16 ו-float זה הופך את סדר הבייטים לכל איבר, דבר שימושי בעת צריכת נתונים מציודים היקפיים שסיומיות שלהם אינה תואמת את המיקרו-בקר. עבור סוגי בייט בודד (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().

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

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

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

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

בִּיטים (מערכי מספרים שלמים בלבד): &, |, ^. החלת פעולות אלו על מערך float מעלה 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, מחזיר טאפל (samples, step).

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. הערכים נכתבים כנקודה צפה.

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

פונקציות מתמטיות אלמנט-אחר-אלמנט. כל אחת מקבלת סקלר או 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.

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.

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#