مصفوفات NumPy: مقدمة [مع أمثلة]

هل تتطلع لبدء استخدام NumPy؟ سيعلمك هذا الدليل أساسيات مصفوفات NumPy في بايثون.

كخطوة أولى ، ستتعلم كيف تعمل مصفوفات NumPy بشكل مختلف عن قوائم Python. ستتعلم بعد ذلك عدة طرق لإنشاء مصفوفات NumPy وتنفيذ العمليات الأساسية عليها.

هيا نبدأ!

أساسيات مصفوفات NumPy

NumPy هي واحدة من أشهر مكتبات Python للحوسبة العلمية وتحليل البيانات. هياكل البيانات الأساسية في NumPy هي مصفوفات ذات أبعاد N (صفائف ND). لديهم قدرات البث وتسمح لنا بتوجيه العمليات من أجل السرعة واستخدام الوظائف الرياضية المضمنة لتحسين الأداء.

لبدء العمل مع NumPy ، يجب عليك أولاً تثبيت المكتبة واستيرادها إلى بيئة العمل الخاصة بك. وهي متوفرة كحزمة PyPI قابلة للتثبيت من خلال النقطة.

لتثبيت NumPy ، افتح الجهاز وقم بتشغيل الأمر التالي:

 pip3 install numpy

بعد تثبيت NumPy ، يمكنك استيراده إلى بيئة العمل الخاصة بك تحت اسم مستعار. الاسم المستعار المعتاد هو np .

 import numpy as np

ملاحظة : استيراد NumPy تحت الاسم المستعار np ليس مطلبًا ولكنه اصطلاح موصى به.

قوائم بايثون مقابل مصفوفات NumPy

ضع في اعتبارك قائمة أرقام بايثون التالية:

 py_list = [1,2,3,4]

يمكنك الحصول على مصفوفة NumPy من قائمة موجودة عن طريق استدعاء الدالة np.array() مع القائمة كوسيط.

 np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4]

للتحقق من نوع np_arr1 ، تقوم باستدعاء دالة type() المضمنة ، سترى أنها ndarray ، وهي بنية البيانات الأساسية في NumPy.

 type(np_arr1) # numpy.ndarray

على الرغم من أن قائمة Python و NumPy قد تبدو متشابهة ، إلا أن هناك اختلافات معينة:

• يمكن لقائمة Python أن تحتوي على كائنات من أنواع بيانات مختلفة ، بينما تحتوي مصفوفة NumPy على عناصر من نفس نوع البيانات. نوع البيانات الافتراضي هو float بدقة 64 بت (float64).
• لا يتم بالضرورة تخزين عناصر قائمة Python في مواقع متجاورة في الذاكرة. ومع ذلك ، يتم تخزين عناصر مصفوفة NumPy في كتلة متجاورة في الذاكرة. نتيجة لذلك ، يكون البحث عن العناصر والوصول إليها أسرع.

لنستعرض بعض الاختلافات الأخرى.

البث

ميزة قوية في مصفوفات NumPy هي البث. لنفترض أننا نرغب في إضافة 2 إلى جميع عناصر np_arr1 و py_list .

دعنا نحاول إضافة 2 إلى py_list ونرى ما سيحدث:

 >>> py_list + 2

نرى أننا حصلنا على خطأ من النوع TypeError ينص على أنه يمكننا فقط ربط قائمتين ، وإضافة py_list + 2 مثل هذا غير مدعوم.

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list

لنجرب نفس العملية على المصفوفة ، np_arr1 .

 >>> np_arr1 + 2

في النتيجة ، نرى أنه تمت إضافة 2 إلى كل عنصر من عناصر المصفوفة.

 array([3, 4, 5, 6])

وذلك لأن NumPy بثت ضمنيًا العدد 2 إلى مصفوفة من الأشكال المتوافقة للحصول على هذه النتيجة.

التوجيه

تدعم مصفوفات NumPy التوجيه لعمليات العناصر بشكل أسرع. لنفترض أننا نرغب في إيجاد مجموع العناصر من المصفوفتين.

سيؤدي استخدام عملية + بسيطة في القائمة إلى إرجاع تسلسل القائمتين (وهذا ليس ما نريده!).

 >>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4]

لكن العملية نفسها على مصفوفة NumPy ، np_arr1 ، تُرجع مجموع العناصر np_arr1 مع نفسه.

 >>> np_arr1 + np_arr1 # array([2, 4, 6, 8])

وبالمثل ، قد تبدو القوائم المتداخلة متشابهة في بنية مصفوفة NumPy ذات الأبعاد N. ومع ذلك ، فإن الخلافات التي نوقشت حتى الآن صامدة.

 nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2)

 [[1 2] [3 4] [5 6]]

كيفية إنشاء مصفوفات NumPy

يمكنك دائمًا إنشاء مصفوفات NumPy من قوائم Python الحالية باستخدام np.array(list-obj) . ومع ذلك ، هذه ليست الطريقة الأكثر فعالية.

بدلاً من ذلك ، يمكنك استخدام العديد من الوظائف المضمنة التي تتيح لك إنشاء مصفوفات ذات شكل معين. شكل المصفوفة عبارة عن مجموعة تشير إلى حجم المصفوفة على طول كل بُعد. على سبيل المثال ، شكل صفيف 2 × 2 مع صفين وعمودين هو (2،2). في هذا القسم ، سوف نتعلم كيفية استخدام بعض هذه الوظائف المضمنة.

تكوين مصفوفات من الأصفار والآحاد

غالبًا ما يكون من المفيد إنشاء مجموعة من الأبعاد المحددة مليئة بالأصفار أو كلها. ثم استخدامها وتعديلها في الخطوات اللاحقة في البرنامج.

يمكننا استخدام الدالة zeros() لإنشاء مصفوفة من الأصفار. قم بتمرير شكل المصفوفة المطلوبة على هيئة مجموعة: np.zeros(shape) .

 array0 = np.zeros((3,3)) print(array0)

هذا هو الإخراج ، مصفوفة ثنائية الأبعاد من الأصفار:

 [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]

يمكنك الوصول إلى سمات مصفوفة dtype ، وسمات الاستدعاء مثل dtype shape ، باستخدام تدوين النقطة ، كما هو موضح أدناه:

 print(array0.dtype) # float64 print(array0.shape) # (3, 3)

للحصول على مصفوفة منها ، يمكنك استخدام الدالة np.ones() .

 array1 = np.ones((3,3)) print(array1)

 [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]

إنشاء مصفوفة الهوية

تستخدم مصفوفة الهوية على نطاق واسع في العديد من التطبيقات في الجبر الخطي. ويمكنك استخدام الدالة np.eye() لإنشاء مصفوفة هوية. تأخذ الدالة np.eye() وسيطة واحدة فقط: ترتيب المصفوفة ( n ).

 arrayi = np.eye(3) print(arrayi)

 [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

تكوين مصفوفات من أرقام عشوائية

يمكنك أيضًا إنشاء مصفوفات لشكل معين مملوءة بأرقام عشوائية مأخوذة من توزيعات محددة. التوزيعات الاحتمالية شائعة الاستخدام هي التوزيع المنتظم والتوزيع الطبيعي القياسي.

يمكن استخدام الدالة randn() ، والتي تعد جزءًا من الوحدة النمطية random في NumPy ، لإنشاء مصفوفات من الأرقام التي يتم أخذ عينات منها من التوزيع العادي القياسي . التوزيع الطبيعي القياسي هو توزيع غاوسي بمتوسط ​​صفر وتباين وحدة.

 std_arr = np.random.randn(3,4) print(std_arr)

 [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() بإرجاع مجموعة من عينات الأرقام من توزيع منتظم عبر الفاصل الزمني [0،1).

 uniform_arr = np.random.rand(2,3) print(uniform_arr)

 [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]]

يمكنك أيضًا إنشاء مصفوفة من الأعداد الصحيحة العشوائية باستخدام وظيفة randint() التي تعد جزءًا من الوحدة النمطية العشوائية في NumPy. np.random.randint(low, high, size) مصفوفة من الأعداد الصحيحة. يتم الاستدلال على شكل المصفوفة من وسيطة size وتأخذ الأعداد الصحيحة قيمًا في الفاصل الزمني [low,high) .

هذا مثال:

 int_arr = np.random.randint(1,100,(2,3)) print(int_arr)

 [[53 89 33] [24 85 33]]

وظائف مدمجة أخرى مفيدة

بعد ذلك ، دعنا ننتقل إلى بعض الوظائف المفيدة الأخرى لإنشاء مصفوفات NumPy.

تقوم الدالة arange() بإرجاع مصفوفة من الأرقام بين قيمة start وقيمة stop في خطوات قيمة step : start ، start + step ، start + 2*step up to but not include stop . قيم start step اختيارية . حجم الخطوة الافتراضي هو 1 وقيمة البدء الافتراضية هي 0.

في هذا المثال ، array_a عبارة عن مصفوفة من الأرقام تبدأ من 1 صعودًا ولكن لا تتضمن 10 في الدرجات 0.5.

 array_a = np.arange(1,10,0.5) print(array_a)

 [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]

يمكنك أيضًا إنشاء مصفوفات من أرقام متباعدة بشكل متساوٍ باستخدام np.linspace() . استخدم np.linspace(start, stop, num) stop على مصفوفة من الأرقام num بشكل متساو بين قيم start والإيقاف.

هنا ، arr_lin عبارة عن مصفوفة مكونة من 5 أرقام متباعدة بشكل متساوٍ في الفترة [1،10].

 array_lin = np.linspace(1,10,5) print(array_lin)

 [ 1. 3.25 5.5 7.75 10. ]

وبالمثل ، فإن arr_lin2 عبارة عن مصفوفة من 10 أرقام متباعدة بشكل متساوٍ في الفترة [1،20].

 array_lin2 = np.linspace(1,20,10) print(array_lin2)

 [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ]

بخلاف وظيفة arange ( arange() ، تتضمن وظيفة linspace() نقطة النهاية افتراضيًا.

العمليات الأساسية على مصفوفات NumPy

بعد ذلك ، لنستعرض بعض العمليات الأساسية في مصفوفات NumPy.

إيجاد العناصر الدنيا والقصوى

عندما نستخدم وظائف من الوحدة النمطية العشوائية في NumPy لإنشاء مصفوفات ، سنحصل على نتيجة مختلفة في كل مرة يتم فيها تشغيل الكود. للحصول على نتائج قابلة للتكرار ، يجب أن نضع بذرة: np.random.seed(seed_value) .

في المثال التالي ، قمت بضبط الأصل للتكاثر ، int_arr1 عبارة عن مصفوفة من سبعة أعداد صحيحة عشوائية في الفترة [1،100).

 np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]

• للعثور على الحد الأقصى للعنصر في المصفوفة ، يمكنك استدعاء طريقة max() على كائن المصفوفة ، int_arr1 ، و
• للعثور على الحد الأدنى للعنصر في المصفوفة ، يمكنك استدعاء طريقة min() في كائن المصفوفة int_arr1 .

 int_arr1.max() # 73 int_arr1.min() # 20

إيجاد فهرس الحد الأقصى والحد الأدنى من العناصر

في بعض الأحيان ، قد تحتاج إلى العثور على فهرس الحد الأقصى والحد الأدنى للعناصر. للقيام بذلك ، يمكنك استدعاء argmax() و argmin() على كائن المصفوفة.

هنا ، الحد الأقصى للعنصر 73 يحدث في الفهرس 2.

 int_arr1.argmax() # 2

ويحدث الحد الأدنى للعنصر 20 عند الفهرس 0.

 int_arr1.argmin() # 0

يمكنك أيضًا استخدام np.argmax(array) و np.argmin(array) للعثور على مؤشرات الحد الأقصى والحد الأدنى من العناصر ، على التوالي. تعرف على المزيد حول argmax() .

كيفية تسلسل مصفوفات NumPy

عملية أخرى شائعة قد ترغب في القيام بها مع مصفوفات NumPy هي التسلسل.

التسلسل العمودي باستخدام vstack

يمكنك تجميع المصفوفات عموديًا باستخدام وظيفة vstack() .

هنا مثال. arr1 عبارة عن مصفوفة من الآحاد تتكون من صفين وثلاثة أعمدة ، و arr2 عبارة عن مصفوفة من الأصفار صفين وثلاثة أعمدة.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

يمكننا تجميع هاتين المصفوفتين عموديًا باستخدام وظيفة vstack() كما هو موضح:

 np.vstack((arr1,arr2))

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

عندما يحدث التراص عموديًا ، يجب أن يكون للمصفوفين نفس عدد الأعمدة .

دعنا نغير arr2 ليكون الشكل (2،2). يحتوي الآن على صفين وعمودين.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))

لذلك ، فإن التسلسل الرأسي غير ممكن ، ونحصل على خطأ في القيمة.

 --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2

التسلسل الأفقي باستخدام hstack

يمكنك تجميع مصفوفات NumPy أفقيًا باستخدام وظيفة hstack() ، كما هو موضح أدناه.

 arr1 = np.ones((3,3)) arr2 = np.zeros((3,2))

 np.hstack((arr1,arr2))

نظرًا لأن التراص يحدث أفقيًا ، يجب أن تحتوي مصفوفات الإدخال على نفس عدد الصفوف . هنا ، يحتوي كل من arr1 و arr2 على ثلاثة صفوف.

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

باستخدام التسلسل

يمكنك أيضًا استخدام مصفوفات NumPy المتسلسلة على طول محور معين باستخدام وظيفة concatenate() . عيّن وسيطة axis الاختيارية على المحور الذي ترغب في الربط معه ؛ القيمة الافتراضية للمحور هي صفر.

وفيما يلي بعض الأمثلة على ذلك:

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

عندما لا نحدد المحور المراد ربطه معًا ، يتم ربط المصفوفات على طول المحور 0. في المصفوفة الناتجة ، تتم إضافة arr2 المصفوفة الثانية (كصفوف) أسفل المصفوفة الأولى.

 np.concatenate((arr1,arr2))

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

عندما نحدد axis = 1 ، نحصل على النتيجة التالية. يتم arr2 (كأعمدة) بجانب المصفوفة الأولى ، arr1 .

 np.concatenate((arr1,arr2),axis=1)

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

كما هو الحال مع hstack() و vstack() ، يجب أن تتطابق أبعاد المصفوفات على طول محور التسلسل.

استنتاج

في هذا البرنامج التعليمي ، تعلمت الاختلافات بين مصفوفات NumPy وقوائم Python ، مع التركيز على مزايا المصفوفات ذات الأبعاد N من حيث السرعة والكفاءة.

لقد تعلمت أيضًا العديد من الوظائف المفيدة لإنشاء مصفوفات ذات بُعد معين وتنفيذ عمليات مشتركة ، مثل العثور على الحد الأدنى والحد الأقصى للعناصر ، والمصفوفات المتسلسلة ، والمزيد.

بعد ذلك ، تعرف على كيفية إعادة تشكيل مصفوفات NumPy.