كيفية تحويل مصفوفة NumPy إلى قائمة في Python (مع أمثلة)

تُعد لغة البرمجة Python إحدى أكثر اللغات البرمجية مرونة وتطوراً في مجال الحوسبة العلمية وهندسة البيانات والذكاء الاصطناعي، ويرجع ذلك بشكل رئيسي إلى نظامها البيئي الغني بالمكتبات المتخصصة وعالية الأداء. من بين هذه المكتبات، تبرز مكتبة NumPy بصفتها العمود الفقري للحوسبة العددية ومعالجة البيانات المصفوفية، حيث تقدم بنية بيانات ثورية تُعرف باسم مصفوفة الأبعاد المتعددة (ndarray). توفر هذه البنية كفاءة حسابية فائقة وسرعة معالجة تقترب من اللغات منخفضة المستوى مثل C وC++ بفضل التخزين المتجاور في الذاكرة والعمليات المتجهة المحسنة.

ومع ذلك، تفرض متطلبات تطوير البرمجيات المعاصرة، وبخاصة في مجالات تطوير الويب وتشييد واجهات برمجة التطبيقات (REST APIs) والتعامل مع قواعد البيانات والتسلسل البياني بصيغة JSON، ضرورة التحويل المستمر بين مصفوفات NumPy المتخصصة وبين بنى البيانات القياسية الأصلية في بايثون، وعلى رأسها القوائم (Lists). تنشأ هذه الضرورة من حقيقة أن العديد من الدوال القياسية والمكتبات الخارجية صُممت لتتعامل حصرياً مع كائنات بايثون الأصلية، مما يجعل فهم آليات التحويل الدقيقة ضرورة برمجية حتمية لكل مطور وعالم بيانات يسعى لبناء أنظمة برمجية متكاملة وقوية وخالية من الأخطاء النوعية.

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

1. مقدمة شاملة حول بنى البيانات في Python: الفروق الجوهرية بين مصفوفات NumPy والقوائم

1.1 الخصائص البنيوية لمصفوفات NumPy (ndarray)

تمثل مصفوفات ndarray في مكتبة NumPy جوهر المعالجة الحسابية المتقدمة في بيئة بايثون، وتستند بنيتها المعمارية على تخزين البيانات في كتل متجاورة ومتصلة داخل الذاكرة العشوائية (Contiguous Memory Allocation). يتيح هذا التوزيع الفيزيائي المنظم لوحدة المعالجة المركزية (CPU) استغلال تقنيات التخزين المؤقت (Cache Locality) إلى أقصى حد ممكن، مما يقلل بشكل جذري من التأخير الزمني المرتبط بجلب البيانات (Memory Latency) أثناء تنفيذ العمليات الحسابية المتكررة.

تشترط مصفوفات NumPy تجانساً صارماً في نوع البيانات (Homogeneous Data Types)، مما يعني أن كل عنصر داخل المصفوفة يجب أن يتشارك في نفس النوع والحجم الثابت بالبايت، مثل int32 أو float64. يلغي هذا التجانس الحاجة إلى تخزين معلومات وصفية إضافية حول نوع كل عنصر على حدة، وهو ما يُعرف بإزالة الغلاف الإضافي لكائنات بايثون (Unboxing). بفضل هذا التصميم، تستفيد العمليات الحسابية من التوجيه المتجه (Vectorized Operations) المبرمج بلغة C والمحسن بواسطة تعليمات المعالجات الحديثة مثل SIMD (Single Instruction, Multiple Data)، مما يحقق أداءً أسرع بعشرات أو مئات المرات مقارنة بالبنى التقليدية.

1.2 الخصائص المعمارية للقوائم القياسية في Python (Lists)

على النقيض تماماً من مصفوفات NumPy، صُممت القوائم القياسية في بايثون لتكون بنى بيانات ديناميكية وغير متجانسة (Heterogeneous Structures) توفر أقصى درجات المرونة للمطور. هيكلياً، لا تحتوي القائمة في بايثون على البيانات الفعلية بشكل متجاور، بل تمثل مصفوفة من المؤشرات (Array of Pointers)، حيث يشير كل مؤشر إلى كائن مستقل في الذاكرة يُعرف باسم PyObject. يحمل كل كائن من هذه الكائنات معلوماته الوصفية الخاصة، بما في ذلك عداد الإشارات (Reference Count) ومحدد النوع (Type Descriptor) والقيمة الفعلية.

تمنح هذه المعمارية القوائم مرونة فائقة تتيح احتواء خليط متنوع من أنواع البيانات ضمن بنية واحدة، مثل النصوص والأرقام والكائنات المخصصة، مع إمكانية التعديل الديناميكي المستمر بالحذف والإضافة دون الحاجة لإعادة تخصيص كامل للذاكرة بفضل استراتيجيات الإفراط في التخصيص التلقائي (Over-allocation). غير أن هذه المرونة تأتي على حساب الكفاءة الحسابية؛ إذ يؤدي التشتت الذاكري وتتبع المؤشرات المستمر (Pointer Chasing) إلى استهلاك كبير للذاكرة وتباطؤ ملحوظ في العمليات الرياضية الكثيفة نتيجة إخفاق التخزين المؤقت للمعالج (CPU Cache Misses).

1.3 دواعي التحويل البرمجي من مصفوفة NumPy إلى قائمة

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

يبرز التحويل كخطوة لا غنى عنها في عمليات الترميز والتسلسل البياني (Serialization)، لا سيما عند تصدير البيانات إلى صيغة JSON عبر وحدات التشفير القياسية المدمجة في بايثون، والتي تطلق استثناءات برمجية فورية عند محاولة تشفير أنواع غير قياسية مثل numpy.int64 أو numpy.ndarray. علاوة على ذلك، يتيح التحويل للمطورين الاستفادة الكاملة من التوابع المدمجة المرنة للقوائم، مثل append() و extend() و pop()، في السياقات التي تتطلب تعديلاً ديناميكياً سريعاً وهيكلة بيانات غير منتظمة لا تتوافق مع القيود الصارمة للمصفوفات الرياضية.

2. الدالة الأساسية للتحويل: المفهوم والآلية التقنية للتابع tolist()

2.1 التشريح الداخلي للتابع ndarray.tolist()

يُعد التابع ndarray.tolist() الأداة الرسمية والمعيارية المصممة داخل نواة مكتبة NumPy لإجراء عملية التحويل الكامل والعميق للمصفوفات إلى قوائم بايثون. يعمل هذا التابع على مستوى كود C الداخلي للمكتبة، حيث يقوم بفحص كل عنصر في المصفوفة، وتفكيك بنية الأرقام الصريحة منخفضة المستوى، ثم إعادة تغليفها داخل كائنات بايثون القياسية المتوافقة (مثل تحويل أرقام C double إلى كائنات float قياسية في بايثون).

يتعامل التابع تلقائياً وبشكل تكراري (Recursively) مع كافة الأبعاد والمستويات الهيكلية للمصفوفة مهما بلغ تعقيدها، مما يضمن تحويل المصفوفات متعددة الأبعاد إلى قوائم متداخلة منظمة تحافظ تماماً على الترتيب المكاني والمنطقي للبيانات الأصلية. نقطة القوة المحورية في هذا التابع تكمن في أنه ينشئ دائماً نسخة جديدة ومستقلة بالكامل (Deep Copy) من البيانات؛ بحيث تنقطع أي علاقة ارتباط في الذاكرة بين المصفوفة المصدر والقائمة الناتجة، مما يمنع حدوث أي آثار جانبية غير مرغوب فيها عند تعديل البيانات لاحقاً.

2.2 الصيغة التركيبية والمعايير البرمجية للدالة

تتميز الصيغة البرمجية لاستخدام التابع بالبساطة والوضوح، حيث يتم استدعاؤه مباشرة كطريقة تابعة لكائن المصفوفة (Method Call) وفق النمط البرمجي الموجه للكائنات:

python_list = my_array.tolist()

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

2.3 التحقق من صحة التحويل ونوع البيانات الناتج

للتحقق الصارم من نجاح عملية التحويل واكتمالها من الناحية البرمجية، يمكن للمطور استخدام الدالة المدمجة type() لفحص نوع الكائن الجذري ونوع العناصر الفرعية المحتواة بداخله. عند تمرير القائمة الناتجة، ستؤكد بايثون تحول الكائن إلى الفئة الأساسية list، مما يثبت التخلص من القيود الهيكلية الخاصة بمكتبة NumPy.

من الضروري أيضاً فحص العناصر الفردية للتأكد من زوال التغليف الخاص بـ NumPy، والتثبت من أن القيم العددية قد تحولت فعلياً من أنواع مثل numpy.int64 أو numpy.float32 إلى الأنواع المدمجة int و float. يمكن كذلك استخدام عامل الهوية is للتحقق من الاستقلال الذاكري التام بين الحاوية الجديدة والمصفوفة الأصلية، مما يضمن أن عمليات التعديل أو الحذف اللاحقة في القائمة لن تؤثر بأي شكل من الأشكال على مصفوفة البيانات الأساسية.

3. تحويل المصفوفات أحادية البعد (1D Arrays) إلى قوائم في Python

3.1 الخطوات البرمجية لتحويل مصفوفة خطية بسيطة

تُمثل المصفوفات أحادية البعد (1D Arrays) أبسط أشكال هياكل البيانات في مكتبة NumPy، وتُستخدم بشكل واسع لتمثيل المتجهات الرياضية والسلاسل الزمنية الخطية. تبدأ عملية التحويل البرمجية باستيراد المكتبة عبر الاسم المستعار المعياري import numpy as np، يليه إنشاء مصفوفة خطية تحتوي على أرقام صحيحة باستخدام إحدى دوال الإنشاء مثل np.array([10, 20, 30, 40]) أو np.arange(1, 10).

يتم تطبيق التابع tolist() على المصفوفة المُنشأة وتخزين الناتج في متغير جديد، ليتم إنتاج قائمة بايثون قياسية تحتوي على نفس تسلسل العناصر. عند طباعة المخرجات للمقارنة البصرية، يُلاحظ بوضوح الفارق في التمثيل النصي؛ حيث تُعرض مصفوفة NumPy دون فواصل بين العناصر ومحاطة بأقواس مربعة، بينما تُعرض القائمة الناتجة مع فواصل صريحة تفصل بين العناصر وفقاً للتمثيل القياسي لبايثون.

3.2 التعامل مع أنواع البيانات العشرية والنصية في المصفوفات الأحادية

تتعامل مصفوفات NumPy مع الأعداد العشرية بدقة فائقة وفق معيار IEEE 754 عبر أنواع مخصصة مثل float32 و float64. عند تحويل مصفوفة أعداد عشرية أحادية البعد باستخدام tolist()، يتم تحويل كل عنصر بدقة متناهية إلى كائن float القياسي في بايثون مع الحفاظ على الدقة العشرية ومطابقة القيمة الحسابية الأصلية دون أي تشويه عددي.

أما في حالة المصفوفات التي تحتوي على سلاسل نصية أو محارف (Strings and Characters)، والتي يتم تمثيلها داخلياً في NumPy بنوع numpy.str_، فإن التابع يقوم باستخراج النصوص وتحويلها إلى كائنات str قياسية تدعم تشفير Unicode العالمي. وبالمثل، عند تحويل مصفوفات القيم المنطقية (Boolean Arrays) ذات النوع numpy.bool_، يتم تحويل العناصر تلقائياً إلى القيم المنطقية الأصلية True و False، مما يتيح استخدامها السلس في الشروط البرمجية التقليدية داخل بايثون.

3.3 تطبيقات وأمثلة عملية على متجهات البيانات الخطية

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

كما يُعد هذا التحويل أساسياً عند تجهيز البيانات الرقمية الخطية لربطها مع مكتبات واجهات المستخدم الرسومية (GUI Frameworks) مثل Tkinter أو PyQt، والتي تتطلب في كثير من عناصر التحكم تمرير قوائم بايثون لعرض الجداول والقوائم المنسدلة. علاوة على ذلك، يسهل التحويل الخطي دمج البيانات مع حلقات التكرار المتقدمة وتمريرها إلى المولدات البرمجية (Generators) لتنفيذ مهام المعالجة المتسلسلة والموزعة.

4. تحويل المصفوفات ثنائية ومتعددة الأبعاد (Multi-Dimensional Arrays) إلى قوائم متداخلة

4.1 تحويل المصفوفات ثنائية الأبعاد (2D Matrices)

تُستخدم المصفوفات ثنائية الأبعاد (2D Matrices) بكثافة في التطبيقات الرياضية لتمثيل الجداول والبيانات الجدولية والمصفوفات الجبرية التي تتألف من صفوف وأعمدة. عند تطبيق التابع tolist() على مصفوفة ثنائية الأبعاد، يقوم النظام تلقائياً بتفكيك البنية المستوية وتحويلها إلى قائمة رئيسية تحتوي بداخلها على مجموعة من القوائم الفرعية، حيث تمثل كل قائمة فرعية صفاً مستقلاً من صفوف المصفوفة الأصلية (List of Lists).

تتيح هذه البنية الناتجة التعامل مع العناصر الفردية باستخدام آلية الفهرسة المزدوجة المتتالية القياسية في بايثون بصيغة matrix_list[row][col]، بدلاً من أسلوب الفهرسة المفردة متعددة الإحداثيات الخاص بمكتبة NumPy بصيغة matrix_array[row, col]. يحافظ هذا التمثيل الهرمي على العلاقات المكانية بين العناصر والصفوف بدقة بالغة، مما يسهل معالجتها في خوارزميات بايثون التقليدية التي تعتمد على القوائم المتداخلة.

4.2 التعامل مع المصفوفات ثلاثية الأبعاد والأبعاد العليا (3D+ Tensors)

تمتد قدرة التابع tolist() البرمجية بسلاسة إلى الفضاءات متعددة الأبعاد ذات الرتب العليا، مثل المصفوفات ثلاثية الأبعاد (3D Arrays) والموترات ذات الأبعاد الرباعية والخماسية المستخدمة في معالجة الصور الملونة والشبكات العصبية والنمذجة المكانية. يقوم التابع بتوليد تداخل هرمي عميق يعكس عدد أبعاد المصفوفة الأصلية بدقة تامة (N-level nested lists).

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

4.3 مقارنة السلوك الهيكلي بين مصفوفة NumPy والقائمة المتداخلة

يفرض الانتقال من مصفوفات NumPy متعددة الأبعاد إلى القوائم المتداخلة تغيراً جذرياً في السلوك الهيكلي والخصائص البرمجية للبيانات. تتميز مصفوفة NumPy بصرامة هندسية تجعل من المستحيل تعديل طول صف واحد دون التأثير على سائر الصفوف، حيث يجب أن تكون أطوال الأبعاد موحدة ومتناغمة في شكل هندسي صلب (Rectangular/Cuboid Shape).

في المقابل، تتمتع القوائم المتداخلة بمرونة ديناميكية تسمح بتعديل أطوال الصفوف الفردية بحرية كاملة، مما يتيح تشكيل ما يُعرف بالقوائم غير المنتظمة (Ragged/Jagged Lists) عن طريق استخدام التوابع append() أو pop() على قائمة فرعية محددة. ومع ذلك، يؤدي هذا التحول إلى فقدان القدرة على استخدام الفهرسة المتجهة الشرائحية المتقدمة (Advanced Slicing) وتطبيق العمليات الرياضية الشاملة على كامل الأعمدة دفعة واحدة دون كتابة حلقات تكرار يدوية.

5. تحويل المصفوفات متعددة الأبعاد إلى قائمة مسطحة (Flattened List)

5.1 الدمج بين التابعين flatten() و tolist()

في كثير من المهام التحليلية، لا تكون هناك رغبة في الاحتفاظ بالتداخل الهرمي للمصفوفات متعددة الأبعاد، بل تكون الحاجة موجهة نحو استخراج كافة العناصر ودمجها في قائمة خطية مسطحة ذات بعد واحد (1D Flattened List). يمثل الدمج التسلسلي للتابعين flatten().tolist() أحد أكثر الأساليب البرمجية انتشاراً ووضوحاً لتحقيق هذه الغاية في بيئة بايثون.

يقوم التابع flatten() أولاً بإنشاء مصفوفة NumPy جديدة أحادية البعد تحتوي على كافة عناصر المصفوفة الأصلية، ثم يأتي دور tolist() لتحويل هذا المتجه الخطي إلى قائمة بايثون القياسية. يدعم التابع flatten() تحديد ترتيب تسطيح العناصر، سواء كان ذلك وفق الترتيب المعتمد في لغة C بناءً على الصفوف أولاً (C-style / Row-major order)، أو الترتيب المعتمد في لغة Fortran بناءً على الأعمدة أولاً (Fortran-style / Column-major order) عبر تمرير المعامل order='F'.

5.2 استخدام التابع ravel() كبديل موفر للموارد قبل التحويل

على الرغم من فاعلية التابع flatten()، إلا أنه يقوم دائماً بتخصيص مساحة ذاكرية جديدة لإنشاء نسخة مادية من المصفوفة المسطحة، وهو ما قد يشكل عبئاً حسابياً عند التعامل مع مجموعات البيانات الكبيرة. كبديل هندسي أكثر كفاءة، يبرز التابع ravel() الذي يحاول إرجاع عرض سطحي (View) للمصفوفة المسطحة دون نسخ البيانات فيزيائياً ما لم تكن هناك ضرورة قسرية تفرضها تقطعات الذاكرة.

عند تطبيق النمط my_array.ravel().tolist()، يتم تجنب عملية النسخ الوسيطة للمصفوفة في الذاكرة قدر الإمكان، حيث يمرر ravel() المرجع الخطي المباشر إلى التابع tolist()، الذي يتولى بدوره إنشاء القائمة النهائية مباشرة. يُعد هذا النهج الخيار المفضل والأنسب في خطوط إنتاج البيانات المقيدة بالذاكرة، حيث يقلل من الاستهلاك المؤقت للذاكرة العشوائية ويسرع من زمن المعالجة الكلي.

5.3 تقنيات التسطيح باستخدام تعبيرات القوائم (List Comprehensions)

توجد بدائل برمجية أخرى لتسطيح المصفوفات تعتمد على أدوات بايثون الأصلية دون الاعتماد على دوال التسطيح في NumPy، ويأتي في مقدمتها استخدام تعبيرات القوائم المتداخلة (Nested List Comprehensions). يتم ذلك عن طريق تحويل المصفوفة متعددة الأبعاد أولاً عبر tolist() ثم تطبيق حلقة تكرار مضمنة لتسطيح الهيكل، مثل الصيغة التالية:

flattened = [item for sublist in my_array.tolist() for item in sublist]

كما يمكن الاعتماد على وحدة itertools القياسية في بايثون عبر الدالة itertools.chain.from_iterable(my_array.tolist()) لتسطيح القوائم بكفاءة عالية. ومع ذلك، تشير الاختبارات القياسية للأداء إلى أن الطرق القائمة مباشرة على نواة NumPy المكتوبة بلغة C مثل my_array.ravel().tolist() تتفوق بفارق شاسع في السرعة وكفاءة استغلال المعالج مقارنة بالحلقات التكرارية المنفذة على مستوى مفسر بايثون.

6. مقارنة تقنية موسعة: التابع tolist() في مواجهة الدالة العامة list()

6.1 سلوك دالة التحويل العامة list(array)

يقع العديد من المطورين المبتدئين في خطأ شائع يتمثل في استخدام الدالة العامة المدمجة في بايثون list(my_array) لتحويل مصفوفات NumPy، دون إدراك الفروق المعمارية الحادة بين هذه الدالة والتابع المتخصص tolist(). تعمل الدالة list() كمكرر عام (Iterable Constructor) يقوم بالمرور فقط على المستوى الأعلى (First Dimension) للكائن الممرر إليه وتحويله إلى قائمة، دون فحص أو معالجة المستويات العميقة.

يترتب على هذا السلوك السطحي مشاكل برمجية جسيمة؛ فعند تطبيق الدالة على مصفوفة ثنائية أو متعددة الأبعاد، تقوم الدالة بإنشاء قائمة تحتوي بداخلها على مصفوفات NumPy فرعية من نوع ndarray وليس قوائم بايثون. علاوة على ذلك، لا تقوم الدالة list() بتحويل أنواع العناصر الفردية إلى أنواع بايثون الأصلية، بل تتركها ككائنات عددية تابعة لمكتبة NumPy، مما يؤدي إلى إنشاء بنية هجينة غير متجانسة تفشل في معالجات التسلسل والتوافق البرمجي.

6.2 جدول مقارنة شامل بين tolist() و list()

يوضح التحليل المقارن التالي الفروق الجوهرية بين التابع المتخصص tolist() ودالة التحويل العامة list() عبر مختلف المعايير التقنية:

• العمق الهيكلي للتحويل: ينفذ التابع tolist() تحويلاً تكرارياً شاملاً وعميقاً لكافة المستويات والأبعاد مهما بلغت درجة تعقيدها، بينما تقتصر الدالة list() على تحويل البعد الخارجي الأول فقط مخلّفة باقي الأبعاد كهياكل NumPy.
• تحويل أنواع البيانات الفردية: يضمن tolist() فك التغليف بالكامل وتحويل كافة الأنواع العددية والمنطقية إلى كائنات بايثون الأصلية (int, float, bool)، في حين تبقي list() على العناصر الفردية ككائنات تابعة لـ NumPy (مثل numpy.int64).
• التوافق مع مكتبات التسلسل (JSON): تتوافق المخرجات الناتجة عن tolist() توافقاً مطلقاً مع دوال التشفير القياسية مثل json.dumps()، بينما تفشل المخرجات المشتقة من list() وتتسبب في إطلاق استثناءات من نوع TypeError.
• كفاءة الاستهلاك المعالجي: يتم تنفيذ tolist() بالكامل على مستوى كود C الداخلي المحسن لمكتبة NumPy، مما يجعله أسرع بكثير في التعامل مع المصفوفات المعقدة مقارنة بالدالة العامة.

6.3 الحالات الاستثنائية التي يُفضل فيها استخدام list()

على الرغم من تفوق tolist() في معظم سيناريوهات التحويل، إلا أن هناك حالات برمجية استثنائية يكون فيها استخدام الدالة العامة list(my_array) مقصوداً ومرغوباً من الناحية الهندسية. تبرز هذه الحالات عندما يرغب المطور في تكرار المعالجة عبر الصفوف أو المقاطع العلوية للمصفوفة، مع الرغبة في الاحتفاظ بالصفوف الفردية كمصفوفات ndarray مصغرة لمواصلة إجراء حسابات متجهة عالية السرعة عليها لاحقاً.

تُعد هذه التقنية مفيدة أيضاً في سياقات هندسة الميزات ونماذج التعلم الآلي التي تتطلب تقسيم البيانات إلى مجموعات دفعية (Batches) يتم تنظيمها داخل قائمة رئيسية، دون المساس بالبنية المصفوفية المحسنة لكل دفعة على حدة. كما تُستخدم كأداة سريعة في الحالات التي يكون فيها التحقق الصارم من استهلاك الذاكرة مطلوباً وتكون المصفوفات أحادية البعد حصراً وموجهة لوظائف تقبل كائنات Iterable العامة.

7. التعامل مع أنواع البيانات المركبة والهجينة أثناء التحويل

7.1 تحويل مصفوفات السجلات والمصفوفات المهيكلة (Structured Arrays)

توفر مكتبة NumPy ميزة متقدمة تُعرف بالمصفوفات المهيكلة (Structured Arrays) ومصفوفات السجلات (Record Arrays)، والتي تتيح للمطورين تعريف هياكل بيانات معقدة تشبه جداول قواعد البيانات أو هياكل لغة C (C Structs)، حيث يحتوي كل عنصر على حقول متعددة بأسماء وأنواع بيانات متباينة (مثل حقل نصي للاسم، وحقل رقمي صحيح للعمر، وحقل عشري للراتب).

عند استدعاء التابع tolist() على مصفوفة مهيكلة، يُظهر التابع سلوكاً هندسياً فريداً؛ حيث يقوم بتحويل كل سجل مهيكل داخل المصفوفة إلى صف بايثون قياسي متصل (Tuple)، مما ينتج في النهاية قائمة من الصفوف القياسية (List of Tuples). يتم فك تغليف كل حقل داخل الصف إلى نوع بايثون القياسي المطابق مع الحفاظ الكامل على ترتيب الحقول وتكامل أنواعها، مما يجعل البيانات جاهزة للإدراج الفوري في قواعد البيانات العلائقية أو تصديرها إلى سجلات بيانات مهيكلة.

7.2 المصفوفات ذات أنواع البيانات المعقدة (Complex Numbers)

تُستخدم الأرقام المركبة (Complex Numbers) بكثافة في مجالات معالجة الإشارات الرقمية، وهندسة الاتصالات، وميكانيكا الكم، والتحليل الطيفي، وتدعمها مكتبة NumPy عبر أنواع متخصصة مثل numpy.complex64 و numpy.complex128. يتميز التابع tolist() بقدرته على التعرف الدقيق على هذه الأرقام وتحويلها تلقائياً إلى كائنات الأرقام المركبة الأصلية في بايثون ذات النوع complex.

يحافظ هذا التحويل على سلامة الأجزاء الحقيقية والتخيلية للرقم (Real and Imaginary Components) بدقة متناهية ودون أدنى فقدان في الحسابات العشرية. كما يتيح للمطورين لاحقاً استخراج الأجزاء الحقيقية والتخيلية داخل القوائم الناتجة باستخدام الخصائص القياسية z.real و z.imag أو تطبيق الدوال الحسابية المعيارية من وحدة cmath المتخصصة.

7.3 مصفوفات الكائنات المخصصة (Object Arrays)

تتيح مكتبة NumPy إنشاء مصفوفات من النوع العام object (أي dtype=object)، والتي تحتوي بداخلها على مراجع لكائنات بايثون مخصصة أو أنواع بيانات غير متجانسة. يُعتبر هذا النوع من المصفوفات استثنائياً؛ نظراً لأنه يفقد ميزة التخزين المتجانس الفعال ويعمل كحاوية للمؤشرات بطريقة شبيهة بالقوائم الأصلية.

عند تطبيق التابع tolist() على مصفوفة كائنات، يقوم التابع باستخراج مراجع الكائنات المخزنة وتغليفها داخل القائمة القياسية الناتجة. تجدر الإشارة هنا إلى أن التابع يقوم بنسخ مراجع الكائنات (Object References) فقط دون إنشاء نسخ عميقة من الكائنات المخصصة ذاتها الكامنة في الذاكرة، مما يفرض على المطورين توخي الحذر عند تعديل الكائنات الداخلية لتجنب الآثار الجانبية المرتبطة بالنسخ السطحي للمراجع.

8. تحليل الأداء الحسابي واستهلاك الذاكرة (Performance and Memory Profiling)

8.1 البصمة الذاكرية لمصفوفات NumPy مقابل القوائم

يمثل التباين في استهلاك الذاكرة بين مصفوفات NumPy وقوائم بايثون أحد أهم الجوانب المعمارية التي يجب على المهندسين مراعاتها عند تصميم التطبيقات. يمكن قياس الحجم الفعلي المحجوز في الذاكرة لكلا الهيكلين باستخدام الدالة القياسية sys.getsizeof()، حيث تكشف القياسات عن تضخم هائل في البصمة الذاكرية عند تحويل المصفوفات إلى قوائم.

يعود هذا التضخم إلى أن مصفوفة NumPy تخزن فقط البيانات الخام المتجاورة بالإضافة إلى رأس مصفوفة صغير وثابت الحجم، بينما تتطلب قائمة بايثون تخزين مصفوفة من مؤشرات الذاكرة بحجم 8 بايت لكل مؤشر على أنظمة 64-بت، فضلاً عن رأس الكائن الخاص بكل رقم منفصل (PyObject Header) الذي يستهلك عادةً ما بين 24 إلى 28 بايت لكل عنصر. يترتب على ذلك زيادة في استهلاك الذاكرة تتراوح غالباً بين 3 إلى 5 أضعاف الحجم الأصلي للمصفوفة، مما يفرض ضغطاً إضافياً على جامع القمامة في بايثون (Garbage Collector) لتتبع وتحرير هذه الكائنات الفردية الكثيرة.

8.2 اختبارات قياس الزمن والسرعة (Time Benchmarks)

أظهرت التجارب القياسية والاختبارات المعملية لزمن التنفيذ (Benchmarking) تبايناً واضحاً في كفاءة التابع tolist() مقارنة بالطرق اليدوية البديلة لتحويل المصفوفات، مثل استخدام حلقات for أو تعبيرات القوائم أو الدالة map(). تم إجراء اختبارات على مصفوفات متدرجة الأحجام من عشرة آلاف عنصر وصولاً إلى عشرات الملايين من العناصر لتحديد نقاط الاختناق في المعالجة.

أثبتت النتائج أن التابع tolist() يتفوق بشكل ساحق على كافة الطرق البديلة المنفذة بلغة بايثون البحتة، محققاً سرعة تنفيذ تتجاوز تعبيرات القوائم بنسب تصل إلى 500% وأكثر؛ نظراً لأن الحلقة التكرارية وعمليات تخصيص الكائنات تتم برمجتها وتجميعها مسبقاً بلغة C المحسنة. ومع ذلك، يظل زمن التحويل الإجمالي مقيداً بسرعة تخصيص الذاكرة العشوائية وتغليف مئات الآلاف من كائنات بايثون المستقلة عند التعامل مع المصفوفات الضخمة جداً.

8.3 استراتيجيات التحسين للأداء في البيئات محدودة الموارد

في البيئات الحوسبية المقيدة بموارد الذاكرة وسرعة المعالجة، مثل الخوادم السحابية ذات الحصص المحدودة أو أجهزة الحوسبة الطرفية (Edge Devices)، يتطلب إجراء التحويل تطبيق استراتيجيات معمارية ذكية لتفادي استنزاف الذاكرة وانهيار التطبيقات. تتمثل إحدى أبرز هذه الاستراتيجيات في تجنب التحويل الشامل لكامل المصفوفة دفعة واحدة، والاستعاضة عن ذلك باستخدام مولدات بايثون (Generators) لتمرير البيانات وتحويلها تدريجياً على شكل أجزاء صغيرة عند الطلب.

كما يُوصى باعتماد تقنية المعالجة على دفعات (Batch Processing / Chunking)، حيث يتم تقطيع المصفوفة الضخمة إلى كتل متساوية الحجم، وتحويل كل كتلة إلى قائمة، ثم معالجتها وتصديرها أو إرسالها للشبكة، تليها عملية استدعاء صريحة لوحدة جمع القمامة gc.collect() لتحرير المساحة فوراً قبل الانتقال للكتلة التالية. علاوة على ذلك، يجب دائماً تأخير خطوة التحويل إلى أقصى نقطة ممكنة في مسار معالجة البيانات، وضمان إتمام كافة العمليات الحسابية والتصفية المعقدة داخل بيئة NumPy السريعة أولاً.

9. معالجة القيم الخاصة والحالات الشاذة: NaNs و Infinities والبيانات المفقودة

9.1 سلوك قيم float(‘nan’) و np.nan بعد التحويل

تُعد معالجة البيانات المفقودة والقيم غير المعرفة (Not a Number – NaN) من أهم التحديات التقنية في علم البيانات وتطوير البرمجيات. تُعرف مكتبة NumPy هذه القيم بالرمز np.nan استناداً إلى المعايير الرياضية لمطابقة العمليات الحسابية غير الصالحة (مثل القسمة على صفر أو حساب الجذر التربيعي لعدد سالب).

عند تطبيق التابع tolist() على مصفوفة تحتوي على قيم np.nan، يتم تحويل هذه القيم إلى كائن الأرقام العشرية القياسي في بايثون الحامل للقيمة float('nan'). يفرض هذا التحول انتباهاً خاصاً من المطور؛ لأن قيم NaN في بايثون تتميز بخاصية رياضية فريدة تتمثل في عدم مطابقتها لأي قيمة بما في ذلك نفسها (أي أن التعبير float('nan') == float('nan') يُرجع دائماً False). لذلك، يُوصى باستخدام دالة التحقق الرياضية math.isnan() لفحص هذه العناصر داخل القوائم، أو استبدال قيم NaN بقيم افتراضية محددة قبل إجراء التحويل باستخدام التابع np.nan_to_num().

9.2 التعامل مع القيم اللانهائية (np.inf و -np.inf)

تمثل القيم اللانهائية الموجبة والسالبة (np.inf و -np.inf) حالات خاصة شائعة الحدوث في الحسابات الرياضية وعمليات الاستمثال الخوارزمي، لا سيما عند وقوع عمليات قسمة على الصفر أو تضخم الحسابات الحسابية إلى ما لا نهاية. عند تحويل مصفوفة تتضمن هذه القيم، ينقل التابع tolist() هذه العناصر بدقة إلى قيم بايثون القياسية المكافئة float('inf') و float('-inf').

رغم أن مفسر بايثون يتعامل مع هذه القيم بسلاسة، إلا أنها قد تسبب أخطاء فادحة عند محاولة تصدير القائمة الناتجة إلى صيغ خارجية مثل JSON؛ نظراً لأن معيار JSON القياسي الصارم (RFC 8259) لا يدعم تمثيل القيم اللانهائية. للتغلب على ذلك، يجب على المطورين تنقية المصفوفات أو القوائم وتصفية هذه القيم أو تحويلها إلى قيم حدية قصوى قابلة للترميز قبل الشروع في عمليات التصدير الشبكي.

9.3 مصفوفات الأقنعة (Masked Arrays) والتحويل الآمن

تقدم مكتبة NumPy وحدة فرعية متخصصة لمعالجة البيانات المعطوبة أو المفقودة تُعرف باسم مصفوفات الأقنعة (Masked Arrays) عبر الفئة numpy.ma.MaskedArray. تحتوي هذه المصفوفات على مصفوفة بيانات أساسية مقترنة بمصفوفة قناع منطقية تحدد العناصر الصالحة والعناصر المحجوبة أو غير الصالحة للاستخدام الإحصائي.

عند استدعاء tolist() مباشرة على مصفوفة مقنعة، يقوم التابع بنسخ كافة القيم مع الاحتفاظ بالقناع، مما قد يؤدي في بعض الإصدارات إلى بقاء القيم غير الصالحة كما هي داخل القائمة. لضمان التحويل الآمن، يُفضل استخدام الدالة compressed() لاستخراج مصفوفة أحادية البعد تحتوي حصراً على البيانات الصالحة وغير المحجوبة قبل تطبيق tolist()، أو تطبيق الدالة filled(fill_value=None) لاستبدال القيم المقنعة بكائن None القياسي داخل بايثون لتمثيل البيانات المفقودة بنزاهة واحترافية.

10. التكامل مع المكتبات والتطبيقات الواقعية في علم البيانات والويب

10.1 تجهيز المخرجات للتسلسل بصيغة JSON وواجهات REST APIs

يواجه مهندسو البرمجيات ومطورو واجهات الويب الخلفية (Backend Developers) بشكل متكرر الخطأ الشهير TypeError: Object of type ndarray is not JSON serializable عند محاولة إرسال مخرجات الحسابات المصفوفية كاستجابة من خوادم الويب عبر مكتبة json المدمجة. يرجع هذا الخطأ إلى عجز مشفر JSON الافتراضي عن قراءة الهياكل المعقدة والأنواع العددية الخاصة بمكتبة NumPy.

يُمثل استخدام التابع tolist() الحل الأمثل والمعياري لإزالة هذا التعارض البرمجي بالكامل؛ حيث يؤدي تحويل المصفوفات وأنواع البيانات المشتقة منها إلى قوائم بايثون وأرقام قياسية إلى تمكين المشفر من تحويل البيانات بسلاسة فائقة وسرعة قياسية دون الحاجة إلى مكتبات خارجية وسيطة. يمكن أيضاً بناء فئات تشفير مخصصة (Custom JSON Encoders) ترث من json.JSONEncoder وتقوم تلقائياً بفحص الكائنات وتطبيق التابع tolist() على أي كائن من نوع ndarray يتم تمريره عبر خطوط نقل البيانات.

10.2 التكامل مع أطر التعلم العميق والآلي (PyTorch و TensorFlow)

في مشاريع الذكاء الاصطناعي والتعلم العميق، يتم تبادل البيانات بانتظام بين أطر الحوسبة الرائدة مثل PyTorch و TensorFlow ومكتبة NumPy. بعد إتمام مرحلة الاستدلال (Inference) واستخراج مصفوفات الاحتمالات والتنبؤات من الموترات (Tensors)، يحتاج المطورون إلى تصدير هذه النتائج لتخزينها أو عرضها للمستخدمين في الواجهات الأمامية.

تتم هذه العملية عبر مسار برمجي متكامل يبدأ بتحويل موتر التعلم العميق إلى مصفوفة NumPy عبر توابع مثل tensor.detach().cpu().numpy()، يليها استدعاء فوري للتابع tolist() لتحويل مصفوفة التنبؤات إلى قائمة بايثون القياسية. يضمن هذا النهج إمكانية تطبيق خوارزميات الترتيب والفلترة اللاحقة على التنبؤات، ودمج نتائج التصنيف والاحتمالات ضمن هياكل التقارير النهائية بسهولة بالغة.

10.3 التبادل البياني مع مكتبة Pandas وقواعد البيانات

تمتلك مكتبة Pandas توافقاً وثيقاً مع مكتبة NumPy؛ حيث تُبنى سلاسل Pandas (Series) وأعمدة إطارات البيانات (DataFrames) داخلياً على مصفوفات NumPy أحادية البعد. يمكن للمطورين تحويل أي عمود في إطار البيانات مباشرة إلى قائمة بايثون عبر استخراج مصفوفة القيم وتطبيق التابع بصيغة df['column_name'].values.tolist() أو استخدام التابع المباشر df['column_name'].to_list().

يُعد هذا التحويل ذا أهمية استراتيجية بالغة عند تجهيز البيانات لإدراجها في قواعد البيانات العلائقية مثل PostgreSQL أو قواعد بيانات NoSQL مثل MongoDB، حيث تتطلب برامج التشغيل (Database Drivers) تمرير المدخلات بتنسيق قوائم ومجموعات قياسية لتنفيذ استعلامات الإدراج المجمعة (Bulk Insert). كما يُستخدم على نطاق واسع في معالجة وتحويل البيانات المكانية والجغرافية ومصفوفات الصور قبل حفظها في حقول البيانات الثنائية أو المتجهة.

11. الأخطاء البرمجية الشائعة واستراتيجيات استكشاف الأخطاء وإصلاحها (Troubleshooting)

11.1 أخطاء نوع البيانات وعدم توافق الكائنات (TypeErrors)

تحدث أخطاء عدم توافق الأنواع (TypeErrors) عند محاولة استدعاء التابع tolist() على كائنات أو بنى برمجية لا تنتمي لفئة ndarray أو لا تدعم هذا التابع، مثل قوائم بايثون القياسية ذاتها أو بعض الكائنات المكررة الأخرى، مما يتسبب في إطلاق الاستثناء AttributeError: 'list' object has no attribute 'tolist'.

لتفادي هذه الأخطاء في البيئات الإنتاجية ذات البيانات الديناميكية، يُوصى بتطبيق الفحص البرمجي الوقائي باستخدام الدالة المدمجة hasattr(obj, 'tolist') للتأكد من قابلية الكائن للتحويل، أو استخدام الدالة isinstance(obj, np.ndarray) للتحقق الصريح من نوع الكائن قبل استدعاء التابع. يساعد هذا الأسلوب الدفاعي في البرمجة على ضمان استقرار التطبيق وتجنب الانهيارات المفاجئة الناتجة عن تباين هياكل المدخلات.

11.2 أخطاء الذاكرة والانهيار عند التعامل مع مصفوفات هائلة (MemoryErrors)

يُمثل استثناء نفاد الذاكرة MemoryError أحد أخطر التحديات التي تواجه المطورين عند محاولة تحويل مصفوفات NumPy هائلة الحجم (تتجاوز عدة غيغابايت) إلى قوائم بايثون. ينجم هذا الخطأ عن حقيقة أن القوائم تتطلب تخصيصاً ذاكرياً مضاعفاً بشكل كبير لكل عنصر ومؤشر، مما يؤدي سريعاً إلى استهلاك كامل مساحة الذاكرة العشوائية المتاحة (RAM) وانهيار بيئة التشغيل.

لتشخيص هذه الأخطاء وحلها، يجب على المهندسين مراقبة استهلاك الذاكرة وحساب الحجم التقديري للقائمة قبل إجراء التحويل. كحلول هندسية عملية، ينبغي اللجوء إلى استراتيجيات التقطيع والتجزئة (Chunking)، أو تخزين المصفوفات كملفات مؤقتة مسقطة على القرص الصلب باستخدام تقنية np.memmap، أو الاستعاضة عن القوائم الكاملة بتمرير كائنات المولدات الكسولة (Lazy Evaluation Generators) التي تستهلك مقداراً ضئيلاً وثابتاً من الذاكرة بغض النظر عن حجم البيانات الإجمالي.

11.3 فقدان كفاءة العمليات المتجهة بسبب التحويل المبكر

يُعد التحويل المبكر لمصفوفات NumPy إلى قوائم بايثون خطأ معمارياً فادحاً يقع فيه العديد من المبرمجين، حيث يؤدي ذلك إلى حرمان النظام البرمجي من الاستفادة من السرعة الخارقة للعمليات المتجهة المحسنة بلغة C، وإجبار المعالج على تنفيذ الحسابات اللاحقة عبر حلقات تكرار مفسرة وبطيئة للغاية على كائنات بايثون المنفصلة.

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

12. الخاتمة: دليل إرشادي لاختيار تقنية التحويل المثلى في المشاريع البرمجية

12.1 ملخص شامل لأفضل الممارسات البرمجية

يقدم هذا الدليل ملخصاً مكثفاً للممارسات المعيارية المعتمدة في الأوساط البرمجية المتقدمة للتعامل مع تحويل المصفوفات إلى قوائم. يظل التابع ndarray.tolist() هو المعيار الذهبي والأكثر أماناً وموثوقية لإجراء التحويل الكامل والعميق للمصفوفات باختلاف أبعادها وأنواع بياناتها، ويجب تفضيله دائماً على الدالة العامة list() عند الرغبة في الحصول على مخرجات متوافقة كلياً مع كائنات بايثون وتنسيقات التسلسل القياسية.

عند الحاجة إلى الحصول على قوائم مسطحة أحادية البعد من مصفوفات معقدة ومتعددة الأبعاد، يُعد النمط البرمجي my_array.ravel().tolist() الخيار الأفضل والأعلى كفاءة في إدارة الذاكرة وسرعة المعالجة. ومن الضروري التمسك بالقواعد الهندسية لإدارة الموارد، ومعالجة القيم الخاصة مثل NaNs واللانهايات قبل التحويل لضمان تكامل المخرجات وسلامتها الحسابية.

12.2 شجرة اتخاذ القرار البرمجي للتحويل (Decision Framework)

لتحديد التقنية البرمجية المثلى بدقة في المشاريع التطبيقية، يمكن الاعتماد على إطار اتخاذ القرار التالي المستند إلى طبيعة البيانات وأهداف المعالجة:

• إذا كانت الغاية هي تصدير البيانات إلى واجهات REST APIs أو ملفات JSON: استخدم ndarray.tolist() حصراً لضمان تحويل كافة العناصر والأبعاد بنجاح ودون أخطاء نوعية.
• إذا كنت بحاجة إلى قائمة خطية مسطحة من مصفوفة متعددة الأبعاد: استخدم ndarray.ravel().tolist() لتحقيق أعلى سرعة وأقل استهلاك لذاكرة النظام.
• إذا كانت المصفوفة ضخمة جداً وتقترب من حدود الذاكرة العشوائية: تجنب التحويل الشامل واعتمد على التجزئة المرحلية (Chunking) أو المولدات الكسولة (Generators).
• إذا كنت ترغب فقط في تكرار المعالجة عبر الصفوف الخارجية مع الإبقاء على الصفوف كمصفوفات متجهة سريعة: استخدم الدالة العامة list(my_array).
• إذا كانت هناك عمليات حسابية أو إحصائية مستمرة: احتفظ بالبيانات داخل مصفوفات NumPy وأجل التحويل إلى نهاية مسار المعالجة.

12.3 التطلعات المستقبلية وتطور بنى البيانات في Python و NumPy

يشهد النظام البيئي للغة بايثون ومكتبة NumPy تطورات متسارعة تهدف إلى تقليص الفجوة في الأداء وتسهيل التبادل البياني بين مختلف المكتبات. تقدم الإصدارات الحديثة من بايثون تحسينات معمارية مستمرة على مفسر اللغة وجامع القمامة وتسريع كائنات القوائم، في حين يواصل فريق تطوير NumPy تعزيز التوافق مع بروتوكولات الذاكرة الموحدة مثل معيار Array API Standard.

تسهم هذه الابتكارات في تسهيل النقل الصفري للبيانات (Zero-copy Data Transfer) بين مصفوفات NumPy وهياكل البيانات الحديثة في مكتبات مثل Apache Arrow وأطر الذكاء الاصطناعي، مما يقلل في المستقبل من الحاجة إلى عمليات النسخ المكلفة في الذاكرة ويوفر آليات تكامل بالغة السرعة تخدم متطلبات التطبيقات البرمجية فائقة الأداء.

المراجع والمصادر الأكاديمية

• Harris, C. R., Millman, K. J., van der Walt, S. J., Gommers, R., Virtanen, P., Cournapeau, D., … & Oliphant, T. E. (2020). Array programming with NumPy. Nature, 585(7825), 357-362. https://doi.org/10.1038/s41586-020-2649-2
• NumPy Developers. (2023). NumPy Reference Documentation: numpy.ndarray.tolist. NumPy.org. https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tolist.html
• Python Software Foundation. (2023). The Python Standard Library: Built-in Types and JSON encoder and decoder. Python.org. https://docs.python.org/3/library/json.html
• van der Walt, S., Colbert, S. C., & Varoquaux, G. (2011). The NumPy array: a structure for efficient numerical computation. Computing in Science & Engineering, 13(2), 22-30. https://doi.org/10.1109/MCSE.2011.37
• McKinney, W. (2022). Python for Data Analysis: Data Wrangling with Pandas, NumPy, and Jupyter (3rd ed.). O’Reilly Media.
• Gorelick, M., & Ozsvald, I. (2020). High Performance Python: Practical Performant Programming for Humans (2nd ed.). O’Reilly Media.