كيفية إعادة تشكيل مصفوفات NumPy في بايثون

في هذا البرنامج التعليمي ، ستتعلم كيفية استخدام NumPy reshape () لإعادة تشكيل مصفوفات NumPy دون تغيير البيانات الأصلية.

عند العمل مع مصفوفات Numpy ، قد ترغب غالبًا في إعادة تشكيل مصفوفة موجودة في مصفوفة ذات أبعاد مختلفة. يمكن أن يكون هذا مفيدًا بشكل خاص عند تحويل البيانات في خطوات متعددة.

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

ما هو إعادة التشكيل في NumPy Arrays؟

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

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

وهنا يأتي دور إعادة التشكيل.

على سبيل المثال ، ضع في اعتبارك الرسم التوضيحي التالي. لدينا متجه – مصفوفة أحادية البعد تتكون من 6 عناصر. ويمكننا إعادة تشكيله إلى مصفوفات من الأشكال 2 × 3 ، 3 × 2 ، 6 × 1 ، وهكذا.

▶ ️ لمتابعة الأمثلة الموجودة في هذا البرنامج التعليمي ، تحتاج إلى تثبيت Python و NumPy. إذا لم يكن لديك NumPy حتى الآن ، فراجع دليل تثبيت NumPy.

يمكنك الآن المضي قدمًا واستيراد NumPy تحت الاسم المستعار np ، عن طريق تشغيل: import numpy as np.

دعنا ننتقل إلى تعلم بناء الجملة في القسم التالي.

بناء جملة إعادة تشكيل NumPy ()

فيما يلي بناء الجملة لاستخدام إعادة تشكيل NumPy ():

np.reshape(arr, newshape, order="C"|'F'|'A')
  • arr هو أي كائن مصفوفة NumPy صالح. هنا ، إنها المصفوفة المراد إعادة تشكيلها.
  • شكل الأخبار هو شكل المصفوفة الجديدة. يمكن أن يكون إما عددًا صحيحًا أو مجموعة.
  • عندما يكون شكل الأخبار عددًا صحيحًا ، يكون المصفوفة التي تم إرجاعها أحادية البعد.
  • يشير الترتيب إلى الترتيب الذي ترغب في قراءته في عناصر المصفوفة المراد إعادة تشكيلها.
  • القيمة الافتراضية هي “C” ، مما يعني أن عناصر المصفوفة الأصلية ستتم قراءتها بترتيب فهرسة يشبه C (بدءًا من 0)
  • يشير الحرف “F” إلى فهرسة فورتران الشبيهة (بدءًا من 1). ويقرأ الحرف “A” في العناصر إما بترتيب C-like أو Fortran اعتمادًا على تخطيط الذاكرة للمصفوفة arr.
  كيفية صنع جرعة سامة في Minecraft

إذن ما الذي يعيده np.reshape ()؟

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

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

عرض مقابل نسخة من مصفوفات NumPy

كما يوحي الاسم ، النسخة هي نسخة من المصفوفة الأصلية. وأي تغييرات يتم إجراؤها على النسخة لن تؤثر على المصفوفة الأصلية.

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

استخدم إعادة تشكيل NumPy () لإعادة تشكيل صفيف 1D إلى مصفوفات ثنائية الأبعاد

# 1. لنبدأ بإنشاء مصفوفة العينة باستخدام np.arange ().

نحتاج إلى مصفوفة من 12 عددًا ، من 1 إلى 12 ، تسمى arr1. نظرًا لأن الدالة NumPy arange () تستبعد نقطة النهاية افتراضيًا ، اضبط قيمة الإيقاف على 13.

الآن دعونا نستخدم الصيغة أعلاه ، ونعيد تشكيل arr1 مع 12 عنصرًا في مصفوفة ثنائية الأبعاد من الشكل (4،3). دعنا نسمي هذا arr2 مع 4 صفوف و 3 أعمدة.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr2 = np.reshape(arr1,(4,3))
print("nReshaped array:")
print(arr2)

دعنا نلقي نظرة على المصفوفات الأصلية والمعاد تشكيلها.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

بدلاً من تمرير المصفوفة كمعامل np.reshape () ، يمكنك أيضًا استدعاء التابع .reshape () على المصفوفة الأصلية.

يمكنك تشغيل dir (arr1) ، وسوف يسرد كل الطرق والسمات الممكنة التي يمكنك استخدامها في كائن المصفوفة arr1.

dir(arr1)

# Output 
[
...
...
'reshape'
...
..
]

في خلية الكود أعلاه ، يمكنك أن ترى أن .reshape () هي طريقة صالحة لاستخدامها في مجموعة NumPy الحالية arr1.

▶ ️ لذلك ، يمكنك أيضًا استخدام البنية المبسطة التالية لإعادة تشكيل مصفوفات NumPy.

arr.reshape(d0,d1,...,dn)

# where:

# d0, d1,..,dn are the dimensions of the reshaped array

# d0 * d1 * ...* dn = N, the number of elements in arr

بالنسبة لبقية هذا البرنامج التعليمي ، دعنا نستخدم هذا النحو في الأمثلة لدينا.

# 2. لنحاول إعادة تشكيل المتجه المكون من 12 عنصرًا إلى مصفوفة 12 × 1.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr3 = arr1.reshape(12,1)
print("nReshaped array:")
print(arr3)

في الإخراج أدناه ، يمكنك أن ترى أنه تم إعادة تشكيل المصفوفة حسب الحاجة.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]]

❔ فكيف نتحقق من حصولنا على نسخة أم منظر؟

  إصلاح الهاتف غير مسموح به خطأ MM6

للتحقق من ذلك ، يمكنك استدعاء السمة الأساسية على المصفوفة التي تم إرجاعها.

  • إذا كانت المصفوفة نسخة ، فإن السمة الأساسية ستكون بلا.
  • إذا كانت المصفوفة عبارة عن طريقة عرض ، فستكون السمة الأساسية هي المصفوفة الأصلية.

دعنا نتحقق من هذا بسرعة.

arr3.base
# Output
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

كما ترى ، ترجع السمة الأساسية لـ arr3 المصفوفة الأصلية. هذا يعني أننا تلقينا عرضًا للمصفوفة الأصلية.

# 3. الآن ، دعنا نحاول إعادة تشكيل المتجه إلى مصفوفة أخرى صالحة 2 × 6.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr4 = arr1.reshape(2,6)
print("nReshaped array:")
print(arr4)

وإليك النتيجة:

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]

في القسم التالي ، دعنا نعيد تشكيل arr1 في مصفوفة ثلاثية الأبعاد.

استخدم إعادة تشكيل NumPy () لإعادة تشكيل صفيف 1D إلى مصفوفات ثلاثية الأبعاد

لإعادة تشكيل arr1 إلى مصفوفة ثلاثية الأبعاد ، دعنا نضبط الأبعاد المطلوبة على (1 ، 4 ، 3).

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr3D = arr1.reshape(1,4,3)
print("nReshaped array:")
print(arr3D)

لقد أنشأنا الآن مصفوفة ثلاثية الأبعاد بنفس 12 عنصرًا مثل المصفوفة الأصلية arr1.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]]

كيفية تصحيح أخطاء القيمة أثناء إعادة التشكيل

إذا كنت تتذكر بناء الجملة ، فإن إعادة التشكيل تكون صالحة فقط عندما يكون حاصل ضرب الأبعاد مساويًا لعدد العناصر في المصفوفة.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr2D = arr1.reshape(4,4)
print("nReshaped array:")
print(arr2D)

هنا ، تحاول إعادة تشكيل مصفوفة مكونة من 12 عنصرًا في مصفوفة 4 × 4 تحتوي على 16 عنصرًا. يقوم المترجم بإلقاء خطأ في القيمة ، كما هو موضح أدناه.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]
-----------------------------------------------------------
ValueError                                
Traceback (most recent call last)
<ipython-input-11-63552bcc8c37> in <module>()
      6 
      7 # Reshape array
----> 8 arr2 = arr1.reshape(4,4)
      9 print("nReshaped array:")
     10 print(arr2)

ValueError: cannot reshape array of size 12 into shape (4,4)

لتجنب مثل هذه الأخطاء ، يمكنك استخدام -1 للاستنتاج التلقائي لشكل أحد الأبعاد – بناءً على العدد الإجمالي للعناصر.

على سبيل المثال ، إذا كنت تعرف أبعاد n – 1 مسبقًا ، فيمكنك استخدام -1 لاستنتاج البعد n في المصفوفة المعاد تشكيلها.

إذا كان لديك مصفوفة من 24 عنصرًا وتريد إعادة تشكيلها في مصفوفة ثلاثية الأبعاد. افترض أنك بحاجة إلى 3 صفوف و 4 أعمدة. يمكنك تمرير القيمة -1 على طول البعد الثالث.

import numpy as np

arr1 = np.arange(1,25)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr_res = arr1.reshape(4,3,-1)
print("nReshaped array:")
print(arr_res)
print(f"Shape of arr_res:{arr_res.shape}")

عندما تفحص شكل صفيف الشكل ، يمكنك أن ترى أن المصفوفة المعاد تشكيلها لها شكل 2 على طول البعد الثالث.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12 
13 14 15 16 17 18 19 20 21 22 23 24]

Reshaped array:
[[[ 1  2]
  [ 3  4]
  [ 5  6]]

 [[ 7  8]
  [ 9 10]
  [11 12]]

 [[13 14]
  [15 16]
  [17 18]]

 [[19 20]
  [21 22]
  [23 24]]]
Shape of arr_res:(4, 3, 2)

هذا مفيد بشكل خاص في تسوية المصفوفة. وستتعرف على ذلك في القسم التالي.

  أفضل 10 موارد مجانية لتعلم Git - نظام التحكم في الإصدار

استخدم إعادة تشكيل NumPy () لتسوية مصفوفة

هناك أوقات تحتاج فيها إلى الرجوع من مصفوفات ذات أبعاد N إلى مصفوفة مسطحة. افترض أنك تريد تسوية صورة إلى متجه طويل من وحدات البكسل.

لنقم بترميز مثال بسيط باستخدام الخطوات التالية:

  • قم بإنشاء مصفوفة صور ذات تدرج رمادي 3 × 3 ، img_arr— بوحدات البكسل في النطاق من 0 إلى 255.
  • بعد ذلك ، قم بتسوية هذا img_arr وطباعة المصفوفة المسطحة ، flat_arr.
  • قم أيضًا بطباعة أشكال img_arr و flat_arr للتحقق.
img_arr = np.random.randint(0, 255, (3,3))
print(img_arr)
print(f"Shape of img_arr: {img_arr.shape}")
flat_arr = img_arr.reshape(-1)
print(flat_arr)
print(f"Shape of flat_arr: {flat_arr.shape}")

ها هو الناتج.

[[195 145  77]
 [ 63 193 223]
 [215  43  36]]
Shape of img_arr: (3, 3)

[195 145  77  63 193 223 215  43  36]
Shape of flat_arr: (9,)

في خلية الكود أعلاه ، يمكنك أن ترى أن flat_arr عبارة عن متجه 1D لقيم البكسل مع 9 عناصر.

تلخيص

حان الوقت لمراجعة ما تعلمناه بسرعة.

  • استخدم np.reshape (arr ، newshape) لإعادة تشكيل arr بالشكل المحدد في شكل الأخبار. شكل الأخبار عبارة عن مجموعة تحدد أبعاد المصفوفة المعاد تشكيلها.
  • بدلاً من ذلك ، استخدم arr.reshape (d0، d1، …، dn) لإعادة تشكيل الشكل ليكون بالشكل d0 x d1 x… x dn
  • تحقق مما إذا كان d0 * d1 *… * dn = N ، عدد العناصر في المصفوفة الأصلية ، لتجنب أخطاء القيمة أثناء إعادة التشكيل.
  • استخدم -1 على الأكثر لبُعد واحد في الشكل الجديد إذا كنت تريد أن يتم استنتاج البُعد تلقائيًا.
  • أخيرًا ، يمكنك استخدام arr.reshape (-1) لتسطيح المصفوفة.

الآن بعد أن عرفت كيفية استخدام NumPy reshape () ، تعرف على كيفية عمل وظيفة NumPy linspace ().

يمكنك تجربة أمثلة التعليمات البرمجية في دفتر Jupyter إذا كنت ترغب في ذلك. إذا كنت تبحث عن بيئات تطوير أخرى ، فراجع دليلنا حول بدائل Jupyter.