شرح NumPy للمبتدئين مع أمثلة عملية

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

NumPy ليست مجرد أداة إضافية، بل هي أساس مهم جدًا في عالم علوم البيانات، والتعلم الآلي، والحوسبة العلمية، وتحليل الصور، والإحصاء، وحتى بعض أجزاء الذكاء الاصطناعي. كثير من المكتبات المشهورة مثل Pandas و SciPy و scikit-learn تعتمد عليها في الخلفية. لذلك، فهم NumPy ليس رفاهية، بل هو خطوة أساسية لأي شخص يريد أن يتقدم فعلًا في بايثون.

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

ما هي NumPy؟

NumPy اختصار لـ Numerical Python، وهي مكتبة مفتوحة المصدر في بايثون مخصصة للتعامل مع البيانات العددية والمصفوفات متعددة الأبعاد بكفاءة عالية.

إذا أردنا أن نقولها بطريقة أبسط:
NumPy تساعدك على تخزين الأرقام والتعامل معها بسرعة ومرونة أكبر من القوائم العادية في بايثون.

الشيء الأهم فيها هو نوع البيانات الأساسي المعروف باسم ndarray، وهو اختصار لـ n-dimensional array، أي مصفوفة ذات عدد غير محدود من الأبعاد تقريبًا.
يمكنك أن تتخيلها كمصفوفة من الأعداد، أو صف واحد، أو جدول، أو حتى بنية ثلاثية الأبعاد تمثل صورًا أو بيانات علمية.

لماذا لا نستخدم القوائم العادية فقط؟

هذا سؤال منطقي جدًا. فبايثون أصلًا لديها القوائم، فلماذا نحتاج NumPy؟

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

• أسرع بكثير في العمليات العددية

• أقل استهلاكًا للذاكرة

• تدعم العمليات على المصفوفات بشكل مباشر

• تمنحك أدوات رياضية وإحصائية كثيرة

• تسهّل التعامل مع البيانات متعددة الأبعاد

مثال بسيط يوضح الفرق:

a = [1, 2, 3]
b = [4, 5, 6]

print(a + b)

النتيجة هنا لن تكون جمعًا عنصرًا بعنصر، بل:

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

أي أنها دمج للقائمتين، وليس جمعًا رياضيًا.

أما في NumPy:

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print(a + b)

النتيجة:

[5 7 9]

وهنا يحدث الجمع الحقيقي عنصرًا بعنصر. وهذا وحده يوضح لك لماذا NumPy مهمة جدًا.

تثبيت NumPy

إذا لم تكن المكتبة مثبتة لديك، يمكنك تثبيتها بالأمر التالي:

pip install numpy

ثم في ملف بايثون:

import numpy as np

الاسم np هو مجرد اختصار شائع جدًا، ويمكنك استخدامه بدل كتابة numpy كاملًا كل مرة.

أول مصفوفة في NumPy

لنبدأ بشيء بسيط جدًا:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print(arr)

النتيجة:

[1 2 3 4 5]

هنا أنشأنا مصفوفة NumPy من قائمة عادية.

نوع البيانات

يمكنك معرفة نوع الكائن:

print(type(arr))

النتيجة غالبًا:

<class 'numpy.ndarray'>

هذا يعني أن arr ليس list بل كائن خاص من نوع ndarray.

الفرق بين list و ndarray

القائمة العادية مرنة جدًا، ويمكنها تخزين أنواع مختلفة:

my_list = [1, "hello", 3.5, True]

لكن NumPy arrays تفضل التناسق، وغالبًا يكون كل العناصر من نفس النوع، وهذا ما يجعلها أسرع وأخف.

إنشاء مصفوفات متعددة الأبعاد

واحدة من أجمل مزايا NumPy هي أنها لا تتوقف عند الصف الواحد.

مصفوفة ثنائية الأبعاد

import numpy as np

arr = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

print(arr)

النتيجة:

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

هذه مصفوفة فيها صفّان وثلاثة أعمدة.

مصفوفة ثلاثية الأبعاد

arr = np.array([
    [
        [1, 2],
        [3, 4]
    ],
    [
        [5, 6],
        [7, 8]
    ]
])

print(arr)

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

خصائص مهمة جدًا في المصفوفات

عندما تبدأ العمل مع NumPy، هناك خصائص يجب أن تحفظها لأنها تساعدك كثيرًا في فهم شكل البيانات.

1) الشكل Shape

import numpy as np

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

النتيجة:

(2, 3)

هذا يعني أن المصفوفة تحتوي على 2 صف و3 أعمدة.

2) عدد الأبعاد ndim

print(arr.ndim)

النتيجة:

2

أي أنها مصفوفة ثنائية الأبعاد.

3) عدد العناصر size

print(arr.size)

النتيجة:

6

4) نوع البيانات dtype

print(arr.dtype)

النتيجة قد تكون:

int64

أو شيء مشابه حسب نظامك.

إنشاء Arrays بطرق مختلفة

NumPy لا تجبرك على طريقة واحدة فقط. هناك عدة طرق لإنشاء المصفوفات.

array

import numpy as np

a = np.array([10, 20, 30])
print(a)

zeros

تنشئ مصفوفة من الأصفار:

z = np.zeros((3, 4))
print(z)

الناتج:

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

ones

o = np.ones((2, 3))
print(o)

full

f = np.full((2, 2), 7)
print(f)

النتيجة:

[[7 7]
 [7 7]]

eye

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

e = np.eye(4)
print(e)

arange

مثل range لكن يعيد مصفوفة:

arr = np.arange(0, 10, 2)
print(arr)

النتيجة:

[0 2 4 6 8]

linspace

لإنشاء أرقام متساوية التباعد بين قيمتين:

arr = np.linspace(0, 1, 5)
print(arr)

النتيجة:

[0.   0.25 0.5  0.75 1.  ]

هذا مفيد جدًا في الرسوم البيانية والتجارب العددية.

فهرسة العناصر Indexing

التعامل مع العناصر داخل المصفوفة يشبه القوائم، لكن أقوى قليلًا.

مصفوفة أحادية الأبعاد

import numpy as np

arr = np.array([10, 20, 30, 40, 50])

print(arr[0])
print(arr[2])
print(arr[-1])

النتيجة:

10
30
50

مصفوفة ثنائية الأبعاد

arr = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print(arr[0, 1])   # الصف الأول، العمود الثاني
print(arr[2, 2])   # الصف الثالث، العمود الثالث

النتيجة:

2
9

هذا الأسلوب واضح جدًا، ويجعل الوصول لأي عنصر مباشرًا.

التقطيع Slicing

التقطيع من أكثر الأشياء التي ستستخدمها كثيرًا.

مثال على مصفوفة أحادية

arr = np.array([10, 20, 30, 40, 50, 60])

print(arr[1:4])
print(arr[:3])
print(arr[3:])
print(arr[::2])

النتائج:

[20 30 40]
[10 20 30]
[40 50 60]
[10 30 50]

مثال على مصفوفة ثنائية

arr = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print(arr[0:2, 1:3])

النتيجة:

[[2 3]
 [5 6]]

هذا يعني: خذ الصفين الأول والثاني، ومن كل صف خذ العمودين الثاني والثالث.

تعديل القيم داخل المصفوفة

يمكنك تغيير القيم بسهولة:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
arr[2] = 100

print(arr)

النتيجة:

[  1   2 100   4   5]

وفي المصفوفات الثنائية:

arr = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

arr[1, 2] = 99
print(arr)

النتيجة:

[[ 1  2  3]
 [ 4  5 99]]

العمليات الحسابية على NumPy Arrays

هنا تبدأ المتعة الحقيقية.

الجمع

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print(a + b)

النتيجة:

[5 7 9]

الطرح

print(b - a)

النتيجة:

[3 3 3]

الضرب

print(a * b)

النتيجة:

[ 4 10 18]

القسمة

print(b / a)

النتيجة:

[4.  2.5 2. ]

الأس

print(a ** 2)

النتيجة:

[1 4 9]

الجذر التربيعي

print(np.sqrt(a))

العمليات على المصفوفات الثنائية

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

print(a + b)
print(a * b)

النتائج تكون عنصرًا بعنصر، وليس ضربًا مصفوفيًا بالمعنى الرياضي التقليدي.

إذا أردت الضرب المصفوفي:

print(a @ b)

أو:

print(np.dot(a, b))

Broadcasting

هذه من أهم المفاهيم في NumPy، وقد تكون مربكة قليلًا في البداية، لكنها مفيدة جدًا.

Broadcasting يعني أن NumPy يستطيع تنفيذ العملية بين مصفوفتين مختلفتي الشكل، بشرط أن يكون التوافق ممكنًا.

مثال بسيط

import numpy as np

arr = np.array([1, 2, 3])
print(arr + 10)

النتيجة:

[11 12 13]

هنا الرقم 10 تم تطبيقه على كل العناصر تلقائيًا.

مثال مع مصفوفة ثنائية

arr = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

print(arr + 100)

النتيجة:

[[101 102 103]
 [104 105 106]]

هذا جميل جدًا لأنه يقلل الحاجة إلى الحلقات.

لماذا Broadcasting مهم؟

لأنه يسمح لك بكتابة كود أقصر وأوضح وأسرع.
بدل أن تكتب حلقة for وتكرر نفس العملية على كل عنصر، NumPy يفعل ذلك داخليًا بشكل أكثر كفاءة.

مثال:

arr = np.array([10, 20, 30, 40])
result = arr * 2 + 5
print(result)

النتيجة:

[25 45 65 85]

الدوال الرياضية المفيدة

NumPy تقدم الكثير من الوظائف الجاهزة.

sum

arr = np.array([1, 2, 3, 4])
print(np.sum(arr))

النتيجة:

10

mean

print(np.mean(arr))

النتيجة:

2.5

min و max

print(np.min(arr))
print(np.max(arr))

std

الانحراف المعياري:

print(np.std(arr))

var

التباين:

print(np.var(arr))

هذه الدوال مهمة جدًا في الإحصاء وتحليل البيانات.

الدوال الإحصائية على المصفوفات

arr = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

print(np.sum(arr))
print(np.sum(arr, axis=0))
print(np.sum(arr, axis=1))

ماذا يعني axis؟

• axis=0 يعني عبر الصفوف، أي عموديًا

• axis=1 يعني عبر الأعمدة، أي أفقيًا

النتائج:

21
[5 7 9]
[ 6 15]

هذا الجزء مهم جدًا، وكثير من المبتدئين يختلط عليهم أول مرة.
تخيل أن axis=0 يجمع كل عمود، وaxis=1 يجمع كل صف.

تغيير شكل المصفوفة reshape

أحيانًا تكون لديك بيانات في شكل واحد وتريد إعادة ترتيبها دون تغيير العناصر.

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])

new_arr = arr.reshape(2, 3)
print(new_arr)

النتيجة:

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

شرط مهم

يجب أن يساوي عدد العناصر قبل وبعد إعادة التشكيل.

مثال غير صحيح:

arr = np.array([1, 2, 3, 4, 5])

# هذا سيفشل لأن 5 عناصر لا يمكن تشكيلها إلى 2x3
# arr.reshape(2, 3)

flatten و ravel

أحيانًا تريد تحويل مصفوفة متعددة الأبعاد إلى مصفوفة مسطحة.

flatten

arr = np.array([[1, 2], [3, 4]])
print(arr.flatten())

ravel

print(arr.ravel())

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

النسخ Copy مقابل العرض View

هذه نقطة مهمة جدًا حتى لا تقع في سلوك غير متوقع.

مثال

import numpy as np

arr = np.array([1, 2, 3, 4])
x = arr.view()
y = arr.copy()

إذا عدلت x فقد يتأثر الأصل، أما y فهو نسخة مستقلة.

x[0] = 100
print(arr)
print(x)
print(y)

هذا المفهوم مهم عندما تتعامل مع بيانات كبيرة، لأن التعديل غير المقصود قد يسبب مشاكل صعبة التتبع.

التكرار Repeat والتجميع Tile

repeat

arr = np.array([1, 2, 3])
print(np.repeat(arr, 2))

النتيجة:

[1 1 2 2 3 3]

tile

print(np.tile(arr, 3))

النتيجة:

[1 2 3 1 2 3 1 2 3]

الفرز Sorting

arr = np.array([50, 20, 10, 40, 30])

print(np.sort(arr))

النتيجة:

[10 20 30 40 50]

وعلى مصفوفة ثنائية:

arr = np.array([
    [3, 1, 2],
    [9, 7, 8]
])

print(np.sort(arr))

سيتم فرز كل صف على حدة.

البحث عن القيم واختيارها

أين توجد القيمة؟

arr = np.array([10, 20, 30, 20, 50])
print(np.where(arr == 20))

النتيجة:

(array([1, 3]),)

هذا يعني أن القيمة 20 موجودة في الفهرسين 1 و3.

استبدال حسب شرط

arr = np.array([10, 20, 30, 40, 50])
result = np.where(arr > 25, arr, 0)
print(result)

النتيجة:

[ 0  0 30 40 50]

التعامل مع القيم الفريدة

arr = np.array([1, 2, 2, 3, 3, 3, 4])

print(np.unique(arr))

النتيجة:

[1 2 3 4]

يمكنك أيضًا معرفة عدد تكرار كل قيمة:

values, counts = np.unique(arr, return_counts=True)
print(values)
print(counts)

إنشاء أرقام عشوائية

NumPy تقدم وحدة قوية جدًا للـ random.

أعداد عشوائية بين 0 و 1

import numpy as np

print(np.random.rand(5))

أعداد صحيحة عشوائية

print(np.random.randint(1, 10, size=5))

مصفوفة عشوائية

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

تثبيت العشوائية Seed

إذا كنت تريد نفس النتائج كل مرة، استخدم seed:

import numpy as np

np.random.seed(42)
print(np.random.randint(1, 100, size=5))

هذا مهم جدًا في التجارب العلمية والتعلم الآلي، لأنك تريد قابلية إعادة النتائج.

مثال عملي: حساب درجات الطلاب

لنأخذ مثالًا واقعيًا وبسيطًا.

لدينا درجات 5 طلاب في 3 اختبارات:

import numpy as np

scores = np.array([
    [80, 90, 85],
    [70, 75, 72],
    [88, 92, 91],
    [60, 65, 70],
    [95, 94, 96]
])

حساب مجموع كل طالب

total_scores = np.sum(scores, axis=1)
print(total_scores)

حساب المتوسط

avg_scores = np.mean(scores, axis=1)
print(avg_scores)

معرفة أعلى درجة في كل اختبار

best_per_test = np.max(scores, axis=0)
print(best_per_test)

معرفة الطالب الأعلى في المتوسط

top_student_index = np.argmax(avg_scores)
print(top_student_index)

إذا كان الناتج 4، فهذا يعني أن الطالب الخامس هو الأعلى.

هذا النوع من التحليل يظهر لك القوة الحقيقية لـ NumPy، لأنه يجعل العمليات الإحصائية واضحة وسريعة جدًا.

مثال عملي: تنظيف بيانات بسيطة

لنفترض أن لديك درجات، وبعض القيم غير منطقية مثل -1 تمثل بيانات مفقودة.

import numpy as np

data = np.array([10, 20, -1, 30, -1, 40])

clean_data = np.where(data == -1, np.nan, data)
print(clean_data)

النتيجة:

[10. 20. nan 30. nan 40.]

ثم يمكنك حساب المتوسط متجاهلًا القيم المفقودة:

print(np.nanmean(clean_data))

هذا مفيد جدًا جدًا في البيانات الواقعية.

مثال عملي: تحليل درجات الحرارة

import numpy as np

temperatures = np.array([18, 20, 22, 19, 25, 27, 24])

print("المتوسط:", np.mean(temperatures))
print("أعلى درجة:", np.max(temperatures))
print("أقل درجة:", np.min(temperatures))
print("الفرق:", np.max(temperatures) - np.min(temperatures))

هذا المثال بسيط، لكنه يوضح كيف يمكن لبايثون وNumPy أن يختصرا الكثير من العمل اليدوي.

مثال عملي: إنشاء جدول بيانات مصغر

import numpy as np

students = np.array([
    [1, 85, 90],
    [2, 78, 88],
    [3, 92, 95],
    [4, 60, 70]
])

ids = students[:, 0]
math_scores = students[:, 1]
science_scores = students[:, 2]

print(ids)
print(math_scores)
print(science_scores)

هذا النوع من الترتيب يساعدك على التفكير بشكل منظم في البيانات.

التعامل مع الشروط

يمكنك استخدام الشروط على المصفوفات مباشرة:

import numpy as np

arr = np.array([5, 12, 18, 7, 25, 30])

print(arr > 10)

النتيجة:

[False  True  True False  True  True]

استخراج القيم الأكبر من 10

print(arr[arr > 10])

النتيجة:

[12 18 25 30]

هذا أسلوب قوي جدًا ويختصر الكود كثيرًا.

استخدام NumPy مع الحلقات

رغم أن NumPy تسمح لك بتقليل الحلقات، أحيانًا لا تزال الحلقات مفيدة. لكن القاعدة العامة هي:
إذا أمكنك استخدام عمليات NumPy المباشرة، فغالبًا سيكون أفضل.

مثال بحلقة

arr = np.array([1, 2, 3, 4])

result = []
for x in arr:
    result.append(x * 2)

print(result)

مثال أفضل باستخدام NumPy

print(arr * 2)

النتيجة نفسها تقريبًا، لكن الكود أبسط وأسرع.

لماذا NumPy أسرع؟

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

لذلك عندما تكبر البيانات، يظهر الفرق بوضوح كبير.

أخطاء شائعة يقع فيها المبتدئون

1) خلط list مع ndarray دون الانتباه

import numpy as np

arr = np.array([1, 2, 3])
lst = [4, 5, 6]

print(arr + lst)

قد يعمل لأن NumPy يحاول التحويل، لكن من الأفضل أن تكون واعيًا لنوع البيانات.

2) نسيان شكل المصفوفة

عند استخدام reshape أو العمليات الثنائية، يجب الانتباه إلى الأبعاد.

3) فهم axis بشكل خاطئ

هذا خطأ شائع جدًا.
خذ وقتك في فهم الفرق بين axis=0 و axis=1.

4) الاعتماد الزائد على الحلقات

NumPy تعطيك بدائل أقوى وأكثر أناقة.

استخدام NumPy في الحياة العملية

قد تتساءل: هل NumPy مفيدة فقط للمبرمجين المتقدمين؟
الجواب: لا، على الإطلاق.

تستخدم في:

• تحليل البيانات

• الإحصاء

• الرسوم البيانية

• التعلم الآلي

• معالجة الصور

• الحسابات العلمية

• بناء النماذج الرياضية

• التجارب والمحاكاة

إذا كنت تعمل مع بيانات في أي شكل، فغالبًا ستحتاج NumPy في مرحلة ما.

مشروع صغير: حساب الأداء الدراسي

لنصنع مثالًا كاملًا قليلاً.

import numpy as np

students = np.array([
    [85, 90, 78],
    [70, 88, 92],
    [95, 91, 89],
    [60, 65, 70],
    [100, 98, 97]
])

# مجموع كل طالب
totals = np.sum(students, axis=1)

# المتوسط
averages = np.mean(students, axis=1)

# أعلى وأقل درجة
highest = np.max(students)
lowest = np.min(students)

print("المجموع:", totals)
print("المتوسط:", averages)
print("أعلى درجة:", highest)
print("أقل درجة:", lowest)

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

تمرين بسيط لتفهم الفكرة

جرب أن تنشئ مصفوفة فيها 10 أرقام، ثم:

• احسب مجموعها

• احسب المتوسط

• استخرج الأرقام الأكبر من 50

• رتبها من الأصغر إلى الأكبر

• استبدل أي رقم أقل من 30 بالرقم 0

مثال:

import numpy as np

arr = np.array([12, 45, 67, 23, 89, 34, 90, 11, 50, 78])

print("المجموع:", np.sum(arr))
print("المتوسط:", np.mean(arr))
print("أكبر من 50:", arr[arr > 50])
print("مرتب:", np.sort(arr))
print("استبدال أقل من 30:", np.where(arr < 30, 0, arr))

هذا النوع من التمرين هو أفضل طريقة لتثبيت الفهم.

متى أستخدم NumPy ومتى أستخدم القوائم العادية؟

استخدم القوائم العادية عندما:

• تحتاج بنية بسيطة جدًا

• تخزن عناصر متنوعة الأنواع

• لا تقوم بعمليات عددية كثيرة

استخدم NumPy عندما:

• تتعامل مع أعداد كثيرة

• تريد أداء أسرع

• تحتاج مصفوفات أو جداول

• تنوي العمل في البيانات أو العلم أو الذكاء الاصطناعي

العلاقة بين NumPy و Pandas

إذا كنت بدأت تسمع عن Pandas، فاعلم أن NumPy هي الأساس الذي تقف عليه الكثير من أدوات تحليل البيانات.

• NumPy ممتازة للمصفوفات والحسابات العددية

• Pandas ممتازة للجداول والبيانات المنظمة

• كثيرًا ما يعملان معًا في نفس المشروع

فهم NumPy سيجعل تعلم Pandas أسهل بكثير.

نصيحة مهمة جدًا للمبتدئ

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

خلاصة الفهم

إذا أردنا تلخيص NumPy في جملة واحدة، فهي:

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

أنت لا تحتاج أن تكون خبيرًا لتبدأ بها.
يكفي أن تفهم:

• كيف تنشئ المصفوفات

• كيف تفهرسها

• كيف تغيرها

• كيف تنفذ عليها العمليات

• كيف تستفيد من broadcasting

• كيف تستخدم الدوال الإحصائية

ومن هنا تبدأ الرحلة الحقيقية.

مثال أخير جامع لكل ما سبق

import numpy as np

# إنشاء مصفوفة
data = np.array([
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
])

# عرض الشكل
print("Shape:", data.shape)

# عنصر محدد
print("عنصر معين:", data[1, 2])

# صف كامل
print("الصف الثاني:", data[1])

# عمود كامل
print("العمود الأول:", data[:, 0])

# مجموع الصفوف
print("مجموع كل صف:", np.sum(data, axis=1))

# المتوسط العام
print("المتوسط:", np.mean(data))

# إضافة رقم لكل العناصر
print("بعد الإضافة:", data + 5)

# إعادة تشكيل
flat = data.reshape(9)
print("مسطحة:", flat)

هذا المثال الصغير يجمع معظم المفاهيم الأساسية في مكان واحد، وهو ممتاز للمراجعة.

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