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

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

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

أجرِ الاختبار: اختبر معلوماتك مع اختبارنا التفاعلي “القوائم مقابل الصفوف في بايثون“. ستحصل على درجة عند إكماله لمساعدتك على تتبع تقدمك في التعلم.

البدء باستخدام القوائم والصفوف في بايثون

في بايثون، القائمة هي مجموعة من الكائنات العشوائية، تُشبه إلى حد ما المصفوفة في العديد من لغات البرمجة الأخرى، ولكنها أكثر مرونة. لتعريف قائمة، عادةً ما تُحاط سلسلة من الكائنات مفصولة بفاصلة بين قوسين مربعين ([])، كما هو موضح أدناه:

>>> colors = ["red", "green", "blue", "yellow"]

>>> colors
['red', 'green', 'blue', 'yellow']

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

وبالمثل، تُعدّ الصفوف أيضًا مجموعات من كائنات عشوائية. لتعريف مصفوفة، يجب وضع سلسلة من الكائنات مفصولة بفاصلة بين قوسين (())، كما هو موضح أدناه:

>>> person = ("Jane Doe", 25, "Python Developer", "Canada")

>>> person
('Jane Doe', 25, 'Python Developer', 'Canada')

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

حتى هذه النقطة، قد يبدو أن القوائم والصفوف متشابهة إلى حد كبير. ومع ذلك، هناك فرق مهم:

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

ملاحظة: في هذا الدرس، سترى المصطلحين المتجانس وغير المتجانس المستخدمين للتعبير عن الأفكار التالية:

متجانسة: كائنات من نفس نوع البيانات أو نفس المعنى الدلالي، مثل سلسلة من الحيوانات، والفواكه، والألوان، وما إلى ذلك.

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

يمكنك إجراء عمليات الفهرسة والتقطيع على كلٍّ من القوائم والصفوف. كما يمكنك إنشاء قوائم وصفوف متداخلة، أو مزيج منهما، مثل قائمة من الصفوف.

الفرق الأبرز بين القوائم والصفوف هو أن القوائم قابلة للتغيير، بينما الصفوف ثابتة. هذه الميزة تُميّزهما وتُحدد استخداماتهما الخاصة.

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

إنشاء القوائم في بايثون

في كثير من الحالات، ستُعرِّف كائن قائمة باستخدام حرف. حرف القائمة هو سلسلة من الكائنات مفصولة بفاصلة بين قوسين مربعين:

>>> countries = ["United States", "Canada", "Poland", "Germany", "Austria"]

>>> countries
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

في هذا المثال، تُنشئ قائمة دول مُمثلة بعناصر نصية. ولأن القوائم مُرتبة، تحتفظ القيم بترتيب الإدراج.

بدلاً من ذلك، يمكنك إنشاء قوائم جديدة باستخدام منشئ ()list:

>>> digits = list(range(10))

>>> digits
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

في هذا المثال، تستخدم دالة ()list لتعريف قائمة أرقام باستخدام كائن range. بشكل عام، يمكن لدالة ()list تحويل أي كائن قابل للتكرار إلى قائمة.

وهذا يعني أنه يمكنك أيضًا استخدامه لتحويل مصفوفة إلى قائمة:

>>> list((1, 2, 3))
[1, 2, 3]

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

>>> even_digits = [number for number in range(1, 10) if number % 2 == 0]

>>> even_digits
[2, 4, 6, 8]

تُعد فهم القوائم أدوات فعّالة لإنشاء القوائم في بايثون. ستجدها غالبًا في شيفرة بايثون التي تُجري تحويلات على تسلسلات البيانات.

أخيرًا، لإنشاء قائمة فارغة، يمكنك استخدام زوج فارغ من الأقواس المربعة أو منشئ القائمة ()list بدون وسيطات:

>>> []
[]

>>> list()
[]

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

إنشاء الصفوف في بايثون

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

>>> connection = ("localhost", "8080", 3, "database.db")

>>> connection
('localhost', '8080', 3, 'database.db')

في هذا المثال، تُنشئ مصفوفة تحتوي على معلمات اتصال قاعدة البيانات. تتضمن البيانات اسم الخادم، والمنفذ، ووقت انتهاء الصلاحية، واسم قاعدة البيانات.

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

>>> contact = "John Doe", "john@example.com", "55-555-5555"

>>> contact
('John Doe', 'john@example.com', '55-555-5555')

عمليًا، يمكنك تعريف الصفوف دون استخدام زوج من الأقواس. مع ذلك، يُعدّ استخدام الأقواس ممارسة شائعة لأنه يُحسّن قابلية قراءة الكود.

نظرًا لأن الأقواس اختيارية، لتحديد عنصر واحد، فأنت بحاجة إلى استخدام فاصلة:

>>> t = (2,)
>>> type(t)
<class 'tuple'>

>>> t = (2)
>>> type(t)
<class 'int'>

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

يمكنك أيضًا إنشاء مصفوفات جديدة باستخدام منشئ ()tuple:

>>> tuple(range(10))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

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

على سبيل المثال، يمكنك تحويل قائمة إلى مصفوفة باستخدام منشئ ()tuple:

>>> tuple([1, 2, 3])
(1, 2, 3)

أخيرًا، لإنشاء مصفوفات فارغة، يمكنك استخدام زوج من الأقواس أو استدعاء ()tuple بدون وسيطات:

>>> ()
()

>>> tuple()
()

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

استكشاف الميزات الأساسية للقوائم والصفوف

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

القوائم والصفوف هي تسلسلات مرتبة

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

>>> ["mango", "orange", "apple"]
['mango', 'orange', 'apple']

>>> ("Jane", 25, "Norway")
('Jane', 25, 'Norway')

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

يمكن أن تحتوي القوائم والصفوف على كائنات عشوائية

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

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

>>> (1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)

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

يمكن أن تكون عناصر القائمة أو المصفوفة أيضًا من أنواع بيانات غير متجانسة:

>>> ["Pythonista", 7, False, 3.14159]
['Pythonista', 7, False, 3.14159]

>>> ("Pythonista", 7, False, 3.14159)
('Pythonista', 7, False, 3.14159)

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

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

يمكن أن تحتوي القوائم والصفوف أيضًا على كائنات مثل الدوال والفئات والوحدات النمطية:

>>> int
<class 'int'>

>>> len
<built-in function len>

>>> def func():
...     pass
...
>>> func
<function func at 0x1053abec0>

>>> import math
>>> math
<module 'math' from '.../math.cpython-312-darwin.so'>

>>> [int, len, func, math]
[
    <class 'int'>,
    <built-in function len>,
    <function func at 0x1053abec0>,
    <module 'math' from '.../math.cpython-312-darwin.so'>
]

>>> (int, len, func, math)
(
    <class 'int'>,
    <built-in function len>,
    <function func at 0x1053abec0>,
    <module 'math' from '.../math.cpython-312-darwin.so'>
)

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

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

>>> list(range(1_000_000))

>>> tuple(range(1_000_000))

سيستغرق تشغيل هذين السطرين من التعليمات البرمجية وملء الشاشة بالعديد من الأرقام بعض الوقت.

أخيرًا، ليس من الضروري أن تكون العناصر في القائمة أو المصفوفة فريدة. يمكن أن يظهر العنصر عدة مرات:

>>> ["bark", "meow", "woof", "bark", "cheep", "bark"]
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']

>>> ("bark", "meow", "woof", "bark", "cheep", "bark")
('bark', 'meow', 'woof', 'bark', 'cheep', 'bark')

يمكن أن تحتوي القوائم والصفوف على قيم مكررة مثل “bark” في الأمثلة أعلاه.

يمكن فهرسة القوائم والصفوف وتقطيعها

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

خذ بعين الاعتبار القائمة التالية:

>>> words = ["foo", "bar", "baz", "qux", "quux", "corge"]

تظهر أدناه مؤشرات العناصر بالكلمات:

إليك كود بايثون للوصول إلى العناصر الفردية للكلمات:

>>> words[0]
'foo'

>>> words[2]
'baz'

>>> words[5]
'corge'

العنصر الأول في القائمة له فهرس 0. العنصر الثاني له فهرس 1، وهكذا. كل شيء تقريبًا يتعلق بالفهرسة يعمل بنفس الطريقة مع الثنائيات.

يمكنك أيضًا استخدام فهرس سلبي، وفي هذه الحالة يبدأ العدد من نهاية القائمة:

فهرسة القائمة السلبية

يتوافق المؤشر -1 مع العنصر الأخير في القائمة، بينما العنصر الأول هو -len(words)، كما هو موضح أدناه:

>>> words[-1]
'corge'

>>> words[-2]
'quux'

>>> words[-len(words)]
'foo'

يعمل التقطيع أيضًا مع القوائم والصفوف. على سبيل المثال، يُرجع التعبير words[m:n] جزء الكلمات من الفهرس m إلى الفهرس n، ولكن لا يشمله.

>>> words[2:5]
['baz', 'qux', 'quux']

تعمل ميزات أخرى للتقطيع مع القوائم أيضًا. على سبيل المثال، يمكنك استخدام المؤشرات الموجبة والسالبة:

>>> words[-5:-2]
['bar', 'baz', 'qux']

>>> words[1:4]
['bar', 'baz', 'qux']

>>> words[-5:-2] == words[1:4]
True

يؤدي حذف المؤشر الأول إلى بدء الشريحة من بداية القائمة أو المصفوفة. أما حذف المؤشر الثاني فيؤدي إلى تمديد الشريحة إلى نهاية القائمة أو المصفوفة.

>>> words[:4]
['foo', 'bar', 'baz', 'qux']
>>> words[0:4]
['foo', 'bar', 'baz', 'qux']

>>> words[2:]
['baz', 'qux', 'quux', 'corge']
>>> words[2:len(words)]
['baz', 'qux', 'quux', 'corge']

>>> words[:4] + words[4:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> words[:4] + words[4:] == words
True

يمكنك تحديد خطوة – إما إيجابية أو سلبية:

>>> words[0:6:2]
['foo', 'baz', 'quux']

>>> words[1:6:2]
['bar', 'qux', 'corge']

>>> words[6:0:-2]
['corge', 'qux', 'bar']

يعمل مُعامل التقطيع ([:]) مع كلٍّ من القوائم والصفوف. يمكنك التحقق من ذلك بتحويل الكلمات إلى مصفوفات، ثم إجراء عمليات التقطيع نفسها عليها.

القوائم قابلة للتغيير، والصفوف غير قابلة للتغيير

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

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

>>> letters = ["A", "B", "c", "d"]  # A list

>>> letters[2] = "C"
>>> letters
['A', 'B', 'C', 'd']

>>> letters[-1] = "D"
>>> letters
['A', 'B', 'C', 'D']

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

الآن، نظرًا لأن الصفوف غير قابلة للتغيير، لا يمكنك أن تفعل مع صف ما ما فعلته في المثال أعلاه مع القائمة:

>>> letters = ("A", "B", "c", "d")  # A tuple

>>> letters[2] = "C"
Traceback (most recent call last):
    ...
TypeError: 'tuple' object does not support item assignment

إذا حاولت تحديث قيمة عنصر مصفوفة، فستحصل على استثناء TypeError لأن الصفوف غير قابلة للتغيير، ولا يُسمح بهذا النوع من العمليات لها.

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

>>> fruits = ["apple", "orange", "mango", "grape"]
>>> del fruits[0]  # Remove apple
>>> fruits
['orange', 'mango', 'grape']

>>> person = ("John Doe", 35, "Web Dev")
>>> del person[1]  # Try to remove the age value
Traceback (most recent call last):
    ...
TypeError: 'tuple' object doesn't support item deletion

يمكنك إزالة عناصر فردية من القوائم باستخدام عبارة del لأن القوائم قابلة للتغيير، ولكن هذا لن يعمل مع الصفوف لأنها غير قابلة للتغيير.

ماذا لو أردت تغيير عدة عناصر في قائمة دفعةً واحدة؟ يتيح بايثون هذه العملية بتعيين شريحة، والذي يتبع الصيغة التالية:

a_list[m:n] = <iterable>

تخيل أن العنصر القابل للتكرار هو حاوية لقيم متعددة، مثل قائمة أو مصفوفة. يستبدل هذا التعيين الجزء المحدد من a_list بمحتوى  <iterable> :

>>> numbers = [1, 2, 3, 0, 0, 0, 7]

>>> numbers[3:6] = [4, 5, 6]
>>> numbers
[1, 2, 3, 4, 5, 6, 7]

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

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

>>> numbers = [1, 2, 3, 7]

>>> numbers[3:4] = [4, 5, 6, 7]
>>> numbers
[1, 2, 3, 4, 5, 6, 7]

في هذا المثال، يمكنك استبدال الرقم 7 بقائمة من القيم من 4 إلى 7. لاحظ كيف يقوم Python تلقائيًا بتوسيع القائمة لك.

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

>>> numbers = [1, 2, 3, 7]

>>> numbers[3:3] = [4, 5, 6]
>>> numbers
[1, 2, 3, 4, 5, 6, 7]

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

لا يمكنك إجراء تعيين شريحة على كائنات الصفوف:

>>> numbers[3:3] = [4, 5, 6]
Traceback (most recent call last):
    ...
TypeError: 'tuple' object does not support item assignment

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

استخدام المشغلات والدوال المضمنة مع القوائم والصفوف

تعمل العديد من مُشغِّلات بايثون والدوال المُدمجة أيضًا مع القوائم والصفوف. على سبيل المثال، يُتيح لك مُشغِّلا in وnot in إجراء اختبارات العضوية على القوائم:

>>> words = ["foo", "bar", "baz", "qux", "quux", "corge"]

>>> "qux" in words
True

>>> "py" in words
False

>>> "thud" not in words
True

يُرجع عامل “in” القيمة “True” إذا كان الكائن المستهدف موجودًا في القائمة، والقيمة “False” في غير ذلك. أما عامل “not in” فيُعطي النتيجة المعاكسة.

تعمل عمليات التجميع (+) والتكرار (*) أيضًا مع القوائم والصفوف:

>>> words + ["grault", "garply"]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']

>>> words * 2
['foo', 'bar', 'baz', 'qux', 'quux', 'corge',
'foo', 'bar', 'baz', 'qux', 'quux', 'corge']

يمكنك أيضًا استخدام الوظائف المضمنة ()len و()min و()max و()sum مع القوائم والصفوف:

>>> numbers = [2, 7, 5, 4, 8]

>>> len(numbers)
5

>>> min(numbers)
2

>>> max(numbers)
8

>>> sum(numbers)
26

في هذا المثال، تُرجع الدالة ()len عدد القيم في القائمة. تُرجع الدالتان ()min و()max الحد الأدنى والحد الأقصى للقيم في القائمة، على التوالي. تُرجع الدالة ()sum مجموع القيم في قائمة الإدخال.

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

استخدام القوائم مقابل الصفوف في بايثون

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

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

وبالمثل، من المناسب استخدام مصفوفة بدلاً من قائمة في المواقف التالية:

• المجموعات غير القابلة للتغيير: عندما يكون لديك مجموعة ثابتة من العناصر التي لا ينبغي أن تتغير، مثل الإحداثيات (x، y، z)، أو قيم ألوان RGB، أو مجموعات أخرى من القيم ذات الصلة.
• الحجم الثابت: عندما لا يتغير حجم المجموعة أثناء تنفيذ الكود.
• البيانات غير المتجانسة: عندما تحتاج إلى تخزين بيانات من نوع غير متجانس أو عندما تمثل البيانات مفهومًا غير متجانس.
• قيم إرجاع الدالة: عندما تقوم الدالة بإرجاع قيم متعددة، فستستخدم عادةً مجموعة لتجميع هذه القيم معًا.

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

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

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