`numpy` --- عمليات المصفوفات المتوافقة مع numpy#

توفر الوحدة الفرعية numpy من ulab واجهة برمجة تطبيقات متوافقة مع numpy مبنية حول نوع المصفوفة متعددة الأبعاد ndarray. وهي تنفذ مجموعة فرعية منتقاة من numpy الخاصة بـ CPython: إنشاء المصفوفات، والعمليات الحسابية على مستوى العناصر، والاختزالات والإحصاءات، والجبر الخطي، وتحويلات فورييه السريعة، وتوليد الأرقام العشوائية، وملاءمة كثيرات الحدود، والإدخال/الإخراج الأساسي.

تُستورد الوحدة الفرعية اصطلاحاً باسم 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 يشكل اسماً مستعاراً لمخزن البيانات الأساسي للمصفوفة. تعدل الكتابة عبر bytearray المُرجعة المصفوفة في مكانها. يُطلق ValueError إذا لم تكن المصفوفة كثيفة (مثل عرض مقتطع).

tolist() → list#: إرجاع محتويات المصفوفة على شكل list بايثونية (قد تكون متداخلة). يساوي عمق التداخل ndim.

transpose() → ndarray#: إرجاع منقول المصفوفة (المحاور معكوسة). بالنسبة للمصفوفات أحادية البعد يُرجع هذا 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().

العوامل المدعومة#

تدعم نسخ ndarray العوامل التالية. تُوزّع العوامل الثنائية معاملاتها وفق قواعد البث القياسية في numpy وتتبع قواعد الترقية في numpy (مثلاً uint8 + int8 => int16، uint16 + int16 => float).

الحساب (ثنائي): +، -، *، /، //، %، **. يُدعم أيضاً المعاملات المنعكسة (على اليمين) والمتغيرات الداخلية +=، -=، *=، /=، %=، **=. يُقبل كلا الشكلَين: ndarray مع ndarray و``ndarray`` مع قيمة عددية مفردة.

المقارنة: ==، و!=، و<، و<=، و>، و>=. تُرجع كل منها ndarray منطقية بشكل البث.

أحادي البت (مصفوفات الأعداد الصحيحة فقط): &، |، ^. تطبيق هذه العمليات على مصفوفة float يُطلق TypeError.

أحادية: + (تُرجع نسخة)، و- (نفي؛ في أنواع dtype غير المؤشرة تلتف القيم بباقي القسمة على \(2^N\))، وabs() (القيمة المطلقة على مستوى العناصر؛ في أنواع dtype غير المؤشرة تُرجع نسخة دون حساب)، و~ (عكس على مستوى البتات، لأنواع dtype الصحيحة فقط)، وlen() (تُرجع طول المحور الأول).

الفهرسة والتقطيع: تُدعم a[i]، وa[i, j, ...]، وa[start:stop:step]، والفهرسة بقناع منطقي (a[mask])، والفهرسة بمصفوفة صحيحة (المتقنة) كلها في عمليات القراءة والكتابة على حد سواء.

التكرار: يؤدي التكرار عبر 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. (لا تترك ulab المخزن غير مهيأ.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray#: إرجاع مصفوفة ثنائية البعد N × M (مربعة N × 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 مع تعيين كل عنصر إلى 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, ...]#: إرجاع صفّ من مصفوفات الإحداثيات من تسلسل من مصفوفات الإحداثيات أحادية البعد. مع indexing 'xy' (الافتراضي) يُعامل أول مدخلين كإحداثيات ديكارتية وتُبدَّل محاور خرجهما؛ ومع 'ij' تُستخدم الفهرسة على نمط المصفوفات. ويقابل التنفيذ المكافئ في NumPy مع copy=True وsparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: إرجاع مصفوفة جديدة من shape وdtype معبأة بالآحاد.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: إرجاع مصفوفة جديدة من shape وdtype معبأة بالأصفار.

الفحص / الطباعة#

numpy.get_printoptions() → dict#: إرجاع خيارات طباعة المصفوفة الحالية على شكل قاموس بالمفتاحين threshold وedgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None#: تعيين خيارات طباعة المصفوفة. threshold هو الحد الأقصى لعدد عناصر المصفوفة المطبوعة بالكامل؛ وedgeitems هو عدد العناصر المعروضة عند كل طرف من المحور عند تلخيص المصفوفة.

numpy.ndinfo(array: ndarray) → None#: طباعة معلومات تشخيصية (الشكل، والخطوات، وdtype، وحجم العنصر، ...) حول 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#: حصر قيم 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#: العنصر الأكبر على مستوى العناصر لمصفوفتين / قيمتين قياسيتين. يجري بث الوسائط معاً؛ وإذا اختلفت أنواع dtype، يُرقّى الخرج.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: العنصر الأصغر على مستوى العناصر لمصفوفتين / قيمتين قياسيتين؛ نظير maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]#: إرجاع صفّ من 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 باستخدام فرز الكومة. مع 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 (تنتج المصفوفات الصحيحة عدداً صحيحاً، والمصفوفات العشرية عدداً عشرياً).

التحويل#

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#: إرجاع الضرب النقطي لمصفوفتين. بالنسبة لمصفوفتين أحاديتي البعد يكون هذا الضرب الداخلي (قيمة قياسية 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). ويُحوَّل ترتيب البايتات أثناء التشغيل إذا اختلف ترتيب بايتات الملف عن ترتيب المضيف.

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 عشرية، تُحوَّل القيم بالتقريب.

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 وتُرجع نتيجة بشكل مطابق (قيمة قياسية عشرية لإدخال قياسي، وndarray لإدخال مصفوفة). عند الاستدعاء بـ ndarray، تكون النتيجة ndarray عشرية جديدة بفاصلة عائمة؛ ويمكن تمرير كلمة مفتاحية اختيارية out لكتابة النتيجة في ndarray عشرية مخصصة مسبقاً بنفس الحجم.

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#: إرجاع كائن قابل للاستدعاء يطبق دالة بايثون 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#: "ليس عدداً" بفاصلة عائمة وفق 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#