الفرق الجوهري بين append() و extend() في قوائم بايثون: دليل شامل مع أمثلة برمجية

مقدمة إلى دوال إدارة القوائم في بايثون

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

في هذا المقال، سنتناول بالتفصيل:

• كيف ومتى تستخدم الدالة .append().
• كيف ومتى تستخدم الدالة .extend().
• الفروقات الرئيسية بينهما مع أمثلة عملية.

لنبدأ رحلتنا في استكشاف هذه الدوال المهمة!

الدالة .append(): إضافة عنصر واحد

دعنا نتعمق في كيفية عمل الدالة .append() وماذا يحدث خلف الكواليس عند استخدامها.

حالات الاستخدام الرئيسية لـ .append()

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

صياغة الدالة .append() ومعاملاتها

لاستدعاء الدالة .append()، ستحتاج إلى استخدام الصياغة التالية:

من اليسار إلى اليمين:

• القائمة التي ستُعدّل: عادةً ما تكون متغيراً يشير إلى القائمة المستهدفة.
• نقطة (.): تتبعها اسم الدالة .append(). تُعرف هذه النقطة بـ "ترميز النقطة" (dot notation)، وهي تشير إلى "استدعاء هذه الدالة على هذه القائمة بالذات"، وبالتالي سيتم تطبيق تأثير الدالة على القائمة الموجودة قبل النقطة.
• بين قوسين: العنصر الذي سيُضاف إلى نهاية القائمة.

أمثلة عملية على استخدام .append()

إليك مثال يوضح كيفية استخدام .append():

# تعريف القائمة
>>> nums = [1, 2, 3, 4]

# إضافة العدد الصحيح 5 إلى نهاية القائمة الحالية
>>> nums.append(5)

# عرض القيمة المحدثة للقائمة
>>> nums
[1, 2, 3, 4, 5]

ملاحظة هامة: عند استخدام .append()، يتم تعديل القائمة الأصلية مباشرةً. لا تقوم الدالة بإنشاء نسخة جديدة من القائمة، بل تُغير القائمة الأصلية في الذاكرة (mutates the original list).

لنفترض أننا نجري بحثاً ونرغب في تحليل البيانات التي تم جمعها باستخدام بايثون. نحتاج إلى إضافة قياس جديد إلى قائمة القيم الموجودة. كيف نفعل ذلك؟ نستخدم الدالة .append()!

# القائمة الحالية
>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]

# إضافة الرقم العشري (float) إلى نهاية القائمة الحالية
>>> nums.append(7.34)

# عرض القيمة المحدثة للقائمة
>>> nums
[5.6, 7.44, 6.75, 4.56, 2.3, 7.34]

ما يعادل .append() باستخدام تقطيع القوائم (Slicing)

إذا كنت على دراية بتقطيع السلاسل النصية أو القوائم أو المجموعات (tuples)، فإن ما تفعله الدالة .append() خلف الكواليس يعادل تقريباً: a[len(a):] = [x].

يوضح هذا المثال أن كلا الطريقتين متكافئتان:

باستخدام .append():

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]
>>> nums.append(4.52)
>>> nums
[5.6, 7.44, 6.75, 4.56, 2.3, 4.52]

باستخدام تقطيع القوائم:

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]
>>> nums[len(nums):] = [4.52]
>>> nums
[5.6, 7.44, 6.75, 4.56, 2.3, 4.52]

إضافة تسلسل كامل كعنصر واحد

ماذا عن هذا المثال؟ ما هو الناتج المتوقع؟

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]
>>> nums.append([5.67, 7.67, 3.44])
>>> nums
# الناتج؟

هل أنت مستعد؟ سيكون هذا هو الناتج:

[5.6, 7.44, 6.75, 4.56, 2.3, [5.67, 7.67, 3.44]]

قد تتساءل: لماذا أُضيفت القائمة بأكملها كعنصر واحد؟ الإجابة تكمن في أن الدالة .append() تُضيف العنصر بأكمله إلى نهاية القائمة. إذا كان العنصر عبارة عن تسلسل (sequence) مثل قائمة، قاموس (dictionary)، أو مجموعة (tuple)، فسيتم إضافة التسلسل بأكمله كعنصر واحد للقائمة الحالية.

لدينا مثال آخر يوضح ذلك. في هذه الحالة، العنصر هو مجموعة (tuple) وقد أُضيف كعنصر واحد للقائمة، وليس كعناصر فردية:

>>> names = ["Lulu", "Nora", "Gino", "Bryan"]
>>> names.append(("Emily", "John"))
>>> names
['Lulu', 'Nora', 'Gino', 'Bryan', ('Emily', 'John')]

الدالة .extend(): إضافة عناصر متعددة من تسلسل

الآن دعنا نتعمق في وظيفة الدالة .extend().

حالات الاستخدام الرئيسية لـ .extend()

يجب عليك استخدام هذه الدالة إذا كنت بحاجة إلى إضافة عدة عناصر إلى قائمة كعناصر فردية. دعني أوضح أهمية هذه الدالة بمقارنتها مع صديقنا الذي تعلمته للتو: الدالة .append().

بناءً على ما تعلمته حتى الآن، إذا أردنا إضافة عدة عناصر فردية إلى قائمة باستخدام .append()، فسنحتاج إلى استخدام .append() عدة مرات، هكذا:

# القائمة التي نريد تعديلها
>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]

# إضافة العناصر
>>> nums.append(2.3)
>>> nums.append(9.6)
>>> nums.append(4.564)
>>> nums.append(7.56)

# القائمة المحدثة
>>> nums
[5.6, 7.44, 6.75, 4.56, 2.3, 2.3, 9.6, 4.564, 7.56]

أنا متأكد من أنك تفكر الآن أن هذه الطريقة ليست فعالة جداً، أليس كذلك؟ ماذا لو احتجت إلى إضافة آلاف أو ملايين القيم؟ لا يمكنني كتابة آلاف أو ملايين الأسطر لهذه المهمة البسيطة. سيستغرق ذلك وقتاً طويلاً جداً!

لذا، دعنا نرى بديلاً. يمكننا تخزين القيم التي نريد إضافتها في قائمة منفصلة ثم استخدام حلقة تكرارية (for loop) لاستدعاء .append() بالقدر المطلوب:

# القائمة التي نريد تعديلها
>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]

# القيم التي نريد إضافتها
>>> new_values = [2.3, 9.6, 4.564, 7.56]

# حلقة تكرارية لإضافة القيم
>>> for num in new_values:
...     nums.append(num)

# القيمة المحدثة للقائمة
>>> nums
[5.6, 7.44, 6.75, 4.56, 2.3, 2.3, 9.6, 4.564, 7.56]

هذه الطريقة أكثر كفاءة، أليس كذلك؟ نحن نكتب بضعة أسطر فقط. ولكن هناك طريقة أكثر كفاءة وقابلية للقراءة واختصاراً لتحقيق نفس الغرض: الدالة .extend()!

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3]
>>> new_values = [2.3, 9.6, 4.564, 7.56]

# هنا يحدث السحر! لا مزيد من حلقات التكرار
>>> nums.extend(new_values)

# تم تحديث القائمة بالقيم الفردية
>>> nums
[5.6, 7.44, 6.75, 4.56, 2.3, 2.3, 9.6, 4.564, 7.56]

صياغة الدالة .extend() ومعاملاتها

لاستدعاء الدالة .extend()، ستحتاج إلى استخدام هذه الصياغة:

من اليسار إلى اليمين:

• القائمة التي ستُعدّل: عادةً ما تكون متغيراً يشير إلى القائمة.
• نقطة (.): حتى الآن، كل شيء مطابق تماماً لما سبق.
• اسم الدالة extend: هنا تبدأ الأمور بالتغير.
• بين قوسين: كائن قابل للتكرار (iterable) (قائمة، مجموعة، قاموس، مجموعة فريدة، أو سلسلة نصية) يحتوي على العناصر التي ستُضاف كعناصر فردية إلى القائمة.

ملاحظة: وفقاً لوثائق بايثون، يُعرّف الكائن القابل للتكرار (iterable) بأنه "كائن قادر على إرجاع أعضائه واحداً تلو الآخر". يمكن استخدام الكائنات القابلة للتكرار في حلقة for، ولأنها تُرجع عناصرها واحداً تلو الآخر، يمكننا "فعل شيء" بكل منها، في كل تكرار.

كيف تعمل .extend() خلف الكواليس

دعنا نرى كيف تعمل الدالة .extend() خلف الكواليس. إليك مثال:

# القائمة التي ستُعدّل
>>> a = [1, 2, 3, 4]

# تسلسل القيم التي نريد إضافتها إلى القائمة a
>>> b = [5, 6, 7]

# استدعاء .extend()
>>> a.extend(b)

# عرض القائمة المحدثة. الآن تحتوي القائمة a على القيم 5، 6، و 7
>>> a
[1, 2, 3, 4, 5, 6, 7]

يمكنك التفكير في .extend() كدالة تُضيف العناصر الفردية للكائن القابل للتكرار بنفس الترتيب الذي تظهر به. في هذه الحالة، لدينا قائمة a = [1, 2, 3, 4] كما هو موضح في الرسم البياني أدناه. ولدينا أيضاً قائمة b = [5, 6, 7] تحتوي على تسلسل القيم التي نريد إضافتها. تأخذ الدالة كل عنصر من b وتُضيفه إلى القائمة a بنفس الترتيب.

الخطوة 1: إضافة العنصر الأول

الخطوة 2: إضافة العنصر الثاني

الخطوة 3: إضافة العنصر الثالث

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

نصيحة: تبقى القائمة b المستخدمة لتوسيع القائمة a سليمة بعد هذه العملية. يمكنك العمل بها بعد استدعاء .extend(). إليك الدليل:

>>> a = [1, 2, 3, 4]
>>> b = [5, 6, 7]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, 7]

# القائمة b سليمة!
>>> b
[5, 6, 7]

أمثلة متنوعة على استخدام .extend() مع أنواع مختلفة من الكائنات القابلة للتكرار

قد تكون فضولياً لمعرفة كيفية عمل الدالة .extend() عند تمرير أنواع مختلفة من الكائنات القابلة للتكرار. دعنا نرى ذلك في الأمثلة التالية:

مع المجموعات (Tuples):

تتم العملية بنفس الطريقة تماماً إذا قمت بتمرير مجموعة (tuple). تُضاف العناصر الفردية للمجموعة واحداً تلو الآخر بالترتيب الذي تظهر به.

# القائمة التي سيتم توسيعها
>>> a = [1, 2, 3, 4]

# القيم التي ستُضاف (الكائن القابل للتكرار هو مجموعة!)
>>> b = (1, 2, 3, 4)

# استدعاء الدالة
>>> a.extend(b)

# تم تحديث قيمة القائمة a
>>> a
[1, 2, 3, 4, 1, 2, 3, 4]

مع المجموعات الفريدة (Sets):

يحدث نفس الشيء إذا قمت بتمرير مجموعة فريدة (set). تُضاف عناصر المجموعة واحداً تلو الآخر. (تذكر أن ترتيب العناصر في المجموعة الفريدة قد لا يكون ثابتاً).

# القائمة التي سيتم توسيعها
>>> a = [1, 2, 3, 4]

# القيم التي ستُضاف (الكائن القابل للتكرار هو مجموعة فريدة!)
>>> c = {5, 6, 7}

# استدعاء الدالة
>>> a.extend(c)

# تم تحديث قيمة a
>>> a
[1, 2, 3, 4, 5, 6, 7]

مع السلاسل النصية (Strings):

تختلف السلاسل النصية قليلاً مع الدالة .extend(). يُعتبر كل حرف من السلسلة النصية "عنصراً"، لذلك تُضاف الأحرف واحداً تلو الآخر بالترتيب الذي تظهر به في السلسلة النصية.

# القائمة التي سيتم توسيعها
>>> a = ["a", "b", "c"]

# السلسلة النصية التي ستُستخدم لتوسيع القائمة
>>> b = "Hello, World!"

# استدعاء الدالة
>>> a.extend(b)

# تم تحديث قيمة a
>>> a
['a', 'b', 'c', 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']

مع القواميس (Dictionaries):

للقواميس سلوك خاص عند تمريرها كمعاملات للدالة .extend(). في هذه الحالة، تُضاف مفاتيح القاموس (keys) واحداً تلو الآخر. أما قيم أزواج المفتاح-القيمة المقابلة فلا تُضاف. في هذا المثال، المفاتيح هي "d"، "e"، و "f". تُضاف هذه القيم إلى القائمة a.

# القائمة التي سيتم توسيعها
>>> a = ["a", "b", "c"]

# القاموس الذي سيُستخدم لتوسيع القائمة
>>> b = {"d": 5, "e": 6, "f": 7}

# استدعاء الدالة
>>> a.extend(b)

# تم تحديث قيمة a
>>> a
['a', 'b', 'c', 'd', 'e', 'f']

ما يعادل .extend() باستخدام تقطيع القوائم (Slicing)

ما تفعله الدالة .extend() يعادل a[len(a):] = iterable. إليك مثال لتوضيح أنهما متكافئان:

باستخدام .extend():

# القائمة التي سيتم توسيعها
>>> a = [1, 2, 3, 4]

# القيم التي ستُضاف
>>> b = (6, 7, 8)

# استدعاء الدالة
>>> a.extend(b)

# تم تحديث القائمة
>>> a
[1, 2, 3, 4, 6, 7, 8]

باستخدام تقطيع القوائم:

# القائمة التي سيتم توسيعها
>>> a = [1, 2, 3, 4]

# القيم التي ستُضاف
>>> b = (6, 7, 8)

# تعليمة الإسناد. إسناد الكائن القابل للتكرار b كجزء نهائي من القائمة a
>>> a[len(a):] = b

# تم تحديث قيمة a
>>> a
[1, 2, 3, 4, 6, 7, 8]

النتيجة هي نفسها، ولكن استخدام .extend() أكثر قابلية للقراءة واختصاراً بكثير، أليس كذلك؟ تقدم بايثون حقاً أدوات مذهلة لتحسين سير عملنا.

ملخص الفروقات الرئيسية بين .append() و .extend()

الآن بعد أن عرفت كيفية العمل مع .append() و .extend()، دعنا نلخص الفروقات الأساسية بينهما:

• التأثير:
  • تُضيف الدالة .append() عنصراً واحداً إلى نهاية القائمة.
  • تُضيف الدالة .extend() عدة عناصر فردية من كائن قابل للتكرار إلى نهاية القائمة.
• الوسيط (Argument):
  • تأخذ الدالة .append() عنصراً واحداً كوسيط.
  • تأخذ الدالة .extend() كائناً قابلاً للتكرار (مثل قائمة، مجموعة، قاموس، مجموعة فريدة، سلاسل نصية) كوسيط.

الخلاصة التقنية

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

آمل أن يكون هذا المقال قد نال إعجابك ووجدته مفيداً. الآن يمكنك العمل بثقة مع الدالتين .append() و .extend() في مشاريع بايثون الخاصة بك.