دليل شامل: استخدام الدالة sort() في بايثون لترتيب القوائم تصاعدياً وتنازلياً مع أمثلة عملية

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

في هذا المقال، ستتعلم:

• كيفية استخدام الدالة sort() وتخصيص وظائفها.
• متى يجب استخدامها ومتى يجب تجنبها.
• كيفية استدعائها بتمرير مجموعات مختلفة من الوسائط.
• كيفية ترتيب قائمة تصاعدياً وتنازلياً.
• كيفية مقارنة عناصر القائمة بناءً على قيم وسيطة.
• كيفية تمرير دوال lambda إلى هذه الدالة.
• مقارنة الدالة sort() بالدالة sorted().
• لماذا تُعد الدالة sort() عملية ترتيب مستقرة (stable sort).
• كيف تعمل عملية التعديل الموضعي (mutation) خلف الكواليس.

هل أنت مستعد؟ لنبدأ رحلتنا في عالم ترتيب القوائم في بايثون!

الغرض وحالات الاستخدام: فهم الترتيب الموضعي

باستخدام الدالة sort()، يمكنك ترتيب قائمة في بايثون بإحدى الطريقتين:

• الترتيب التصاعدي (Ascending Order)
• الترتيب التنازلي (Descending Order)

تُستخدم هذه الدالة لترتيب القائمة في مكانها (in place)، مما يعني أنها تقوم بتعديل القائمة الأصلية مباشرةً دون إنشاء نُسخ إضافية. لذا، تذكر دائماً هذه النقطة الأساسية:

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

• كنت ترغب في تعديل (ترتيب) القائمة بشكل دائم.
• لم تكن بحاجة للاحتفاظ بالنسخة الأصلية من القائمة.

إذا كانت هذه المتطلبات تتناسب مع احتياجاتك، فإن الدالة .sort() هي بالضبط ما تبحث عنه.

بناء الجملة والوسائط: إطلاق العنان لقوة التخصيص

دعنا نرى كيف يمكنك استدعاء الدالة .sort() للاستفادة من كامل قوتها. هذا هو الاستدعاء الأكثر بساطة (بدون وسائط):

إذا لم تمرر أي وسائط، فبشكل افتراضي:

• سيتم ترتيب القائمة تصاعدياً.
• ستتم مقارنة عناصر القائمة مباشرةً باستخدام قيمها مع المعامل <.

على سبيل المثال:

 >>> b = [ 6 , 3 , 8 , 2 , 7 , 3 , 9 ]
 >>> b.sort()
 >>> b
 [ 2 , 3 , 3 , 6 , 7 , 8 , 9 ] # تم الترتيب!

الوسائط المخصصة: key و reverse

لتخصيص طريقة عمل الدالة sort()، يمكنك تمرير وسيطين اختياريين:

• key
• reverse

دعنا نرى كيف يغيران سلوك هذه الدالة. هنا لدينا استدعاء دالة بهذين الوسيطين:

قبل شرح كيفية عملهما، أود أن أوضح شيئاً ربما لاحظته في الرسم البياني أعلاه – في استدعاء الدالة، يجب تضمين أسماء المعلمات قبل قيمها المقابلة، مثل هذا:

• key=<f>
• reverse=<value>

هذا لأنها وسائط مخصصة بالكلمة المفتاحية فقط (keyword-only arguments). إذا كنت تمرر قيمة مخصصة لها، فيجب تحديد أسمائها في استدعاء الدالة، متبوعة بعلامة يساوي = وقيمها المقابلة، مثل هذا:

وإلا، إذا حاولت تمرير الوسائط مباشرةً كما نفعل عادةً للمعلمات الموضعية (positional parameters)، فسترى هذا الخطأ لأن الدالة لن تعرف أي وسيط يتوافق مع أي معلمة:

TypeError: sort() takes no positional arguments

الوسيط reverse: التحكم في اتجاه الترتيب

الآن بعد أن عرفت ما هي وسائط الكلمة المفتاحية فقط، دعنا نبدأ بالوسيط reverse. يمكن أن تكون قيمة reverse إما True أو False:

• False: تعني أن القائمة سيتم ترتيبها تصاعدياً.
• True: تعني أن القائمة سيتم ترتيبها تنازلياً (عكسياً).

💡 نصيحة: بشكل افتراضي، تكون قيمته False – إذا لم تمرر أي وسائط لهذه المعلمة، فسيتم ترتيب القائمة تصاعدياً.

هنا لدينا بعض الأمثلة:

بشكل افتراضي، reverse هو False:

 # قائمة من الأعداد الصحيحة
 >>> b = [ 6 , 3 , 8 , 2 , 7 , 3 , 9 ]
 >>> b.sort()
 >>> b
 [ 2 , 3 , 3 , 6 , 7 , 8 , 9 ]

 # قائمة من السلاسل النصية
 >>> c = [ "A" , "Z" , "D" , "T" , "U" ]
 >>> c.sort()
 >>> c
 [ 'A' , 'D' , 'T' , 'U' , 'Z' ]

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

لتحديد أن reverse هو True، بحيث يجب ترتيب القائمة تنازلياً (عكسياً):

 # قائمة من الأعداد الصحيحة
 >>> b = [ 6 , 3 , 8 , 2 , 7 , 3 , 9 ]
 >>> b.sort(reverse=True)
 >>> b
 [ 9 , 8 , 7 , 6 , 3 , 3 , 2 ]

 # قائمة من السلاسل النصية
 >>> c = [ "A" , "Z" , "D" , "T" , "U" ]
 >>> c.sort(reverse=True)
 >>> c
 [ 'Z' , 'U' , 'T' , 'D' , 'A' ]

💡 نصيحة: لاحظ كيف يتم ترتيب القائمة تنازلياً إذا كانت قيمة reverse هي True.

الوسيط key: تحديد معيار المقارنة

الآن بعد أن عرفت كيفية العمل مع المعلمة reverse، دعنا نرى المعلمة key. هذه المعلمة أكثر تفصيلاً بعض الشيء لأنها تحدد كيفية مقارنة عناصر القائمة أثناء عملية الترتيب.

بناء الجملة الأساسي

يمكن أن تكون قيمة key إما:

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

💡 نصيحة: بشكل افتراضي، تكون قيمة key هي None، لذلك تتم مقارنة العناصر مباشرةً.

على سبيل المثال: لنفترض أننا نريد ترتيب قائمة من السلاسل النصية بناءً على طولها، من أقصر سلسلة إلى أطول سلسلة. يمكننا تمرير الدالة len كقيمة للوسيط key، مثل هذا:

 >>> d = [ "aaa" , "bb" , "c" ]
 >>> d.sort(key=len)
 >>> d
 [ 'c' , 'bb' , 'aaa' ]

💡 نصيحة: لاحظ أننا نمرر اسم الدالة فقط (len) بدون أقواس لأننا لا نستدعي الدالة. هذا مهم جداً.

لاحظ الفرق بين مقارنة العناصر مباشرةً ومقارنة طولها (انظر أدناه). استخدام القيمة الافتراضية للوسيط key (None) كان سيرتب السلاسل أبجدياً (يسار)، ولكن الآن نقوم بترتيبها بناءً على طولها (يمين):

ماذا يحدث خلف الكواليس؟

يتم تمرير كل عنصر كوسيط إلى الدالة len()، وتُستخدم القيمة التي تُرجعها هذه الدالة لإجراء المقارنات أثناء عملية الترتيب:

ينتج عن هذا قائمة بمعيار ترتيب مختلف: الطول.

هنا لدينا مثال آخر: مثال آخر مثير للاهتمام هو ترتيب قائمة من السلاسل النصية كما لو كانت كلها مكتوبة بأحرف صغيرة (على سبيل المثال، جعل "Aa" مكافئاً لـ "aa"). وفقاً للترتيب المعجمي (lexicographical order)، تأتي الأحرف الكبيرة قبل الأحرف الصغيرة:

 >>> "E" < "e"
 True

لذلك فإن السلسلة "Emma" ستأتي قبل "emily" في قائمة مرتبة، حتى لو كانت إصداراتها بالأحرف الصغيرة ستكون بترتيب معاكس:

>>> "Emma" < "emily"
True
>>> "emma" < "emily"
False

لتجنب التمييز بين الأحرف الكبيرة والصغيرة، يمكننا تمرير الدالة str.lower كـ key. سيؤدي هذا إلى إنشاء نسخة صغيرة من السلاسل التي ستُستخدم للمقارنات:

 >>> e = [ "Emma" , "emily" , "Amy" , "Jason" ]
 >>> e.sort(key=str.lower)
 >>> e
 [ 'Amy' , 'emily' , 'Emma' , 'Jason' ]

لاحظ أنه الآن، تأتي "emily" قبل "Emma" في القائمة المرتبة، وهو بالضبط ما أردناه.

💡 نصيحة: لو كنا استخدمنا عملية الترتيب الافتراضية، لكانت جميع السلاسل التي تبدأ بحرف كبير قد جاءت قبل جميع السلاسل التي تبدأ بحرف صغير:

 >>> e = [ "Emma" , "emily" , "Amy" , "Jason" ]
 >>> e.sort()
 >>> e
 [ 'Amy' , 'Emma' , 'Jason' , 'emily' ]

مثال باستخدام البرمجة كائنية التوجه (OOP)

إذا كان لدينا هذا الفئة البسيطة جداً في بايثون:

 >>> class Client :
 def __init__ ( self, age ):
 self.age = age

وقمنا بإنشاء أربعة كائنات (instances) منها:

 >>> client1 = Client( 67 )
 >>> client2 = Client( 23 )
 >>> client3 = Client( 13 )
 >>> client4 = Client( 35 )

يمكننا إنشاء قائمة تشير إليها:

 >>> clients = [client1, client2, client3, client4]

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

 >>> def get_age ( client ):
 return client.age

يمكننا ترتيب القائمة بناءً على أعمارهم عن طريق تمرير الدالة get_age كوسيط:

 >>> clients.sort(key=get_age)

هذه هي النسخة النهائية المرتبة من القائمة. نستخدم حلقة for لطباعة عمر الكائنات بالترتيب الذي تظهر به في القائمة:

 >>> for client in clients:
 print(client.age)
 13
 23
 35
 67

بالضبط ما أردناه – الآن القائمة مرتبة تصاعدياً بناءً على عمر الكائنات.

💡 نصيحة: بدلاً من تعريف دالة get_age، كان بإمكاننا استخدام دالة lambda للحصول على عمر كل كائن، مثل هذا:

 >>> clients.sort(key= lambda x: x.age)

دوال lambda هي دوال صغيرة وبسيطة ومجهولة الاسم (anonymous functions)، مما يعني أنها لا تحمل اسماً. إنها مفيدة جداً في هذه السيناريوهات عندما نريد استخدامها فقط في أماكن معينة ولفترة قصيرة جداً.

هذا هو الهيكل الأساسي لدالة lambda التي نستخدمها لترتيب القائمة:

تمرير كلا الوسيطين: key و reverse معاً

رائع! الآن أنت تعرف كيفية تخصيص وظائف الدالة sort(). ولكن يمكنك الارتقاء بمهاراتك إلى مستوى جديد تماماً من خلال الجمع بين تأثير key و reverse في نفس استدعاء الدالة:

 >>> f = [ "A" , "a" , "B" , "b" , "C" , "c" ]
 >>> f.sort(key=str.lower, reverse=True)
 >>> f
 [ 'C' , 'c' , 'B' , 'b' , 'A' , 'a' ]

هذه هي المجموعات المختلفة للوسائط وتأثيرها:

ترتيب وسائط الكلمة المفتاحية فقط لا يهم

بما أننا نحدد أسماء الوسائط، فإننا نعرف بالفعل أي قيمة تتوافق مع أي معلمة، لذلك يمكننا تضمين key أو reverse أولاً في القائمة وسيكون التأثير هو نفسه تماماً. لذا فإن استدعاء الدالة هذا:

مكافئ لـ:

هذا مثال:

 >>> a = [ "Zz" , "c" , "y" , "o" , "F" ]
 >>> a.sort(key=str.lower, reverse=True)
 >>> a
 [ 'Zz' , 'y' , 'o' , 'F' , 'c' ]

إذا غيرنا ترتيب الوسائط، نحصل على نفس النتيجة تماماً:

 >>> a = [ "Zz" , "c" , "y" , "o" , "F" ]
 >>> a.sort(reverse=True, key=str.lower)
 >>> a
 [ 'Zz' , 'y' , 'o' , 'F' , 'c' ]

القيمة المرجعة: لماذا تُرجع None؟

الآن دعنا نتحدث قليلاً عن القيمة المرجعة لهذه الدالة. الدالة sort() تُرجع None – فهي لا تُرجع نسخة مرتبة من القائمة، كما قد نتوقع بشكل بديهي. وفقاً لتوثيق بايثون:

لتذكير المستخدمين بأنها تعمل بتأثير جانبي (side effect)، فإنها لا تُرجع التسلسل المرتب.

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

 >>> nums = [ 6.5 , 2.4 , 7.3 , 3.5 , 2.6 , 7.4 ]
 # تعيين القيمة المرجعة لهذا المتغير:
 >>> val = nums.sort()
 # التحقق من القيمة المرجعة:
 >>> print(val)
 None

هل ترى؟ تم إرجاع None بواسطة استدعاء الدالة.

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

 # الدالة sort() تُرجع None
 >>> nums = [ 6.5 , 2.4 , 7.3 , 3.5 , 2.6 , 7.4 ]
 >>> val = nums.sort()
 >>> print(val)
 None

 # الدالة sorted() تُرجع نسخة جديدة مرتبة من القائمة الأصلية
 >>> nums = [ 6.5 , 2.4 , 7.3 , 3.5 , 2.6 , 7.4 ]
 >>> val = sorted(nums)
 >>> val
 [ 2.4 , 2.6 , 3.5 , 6.5 , 7.3 , 7.4 ]
 # لكنها لا تُعدّل القائمة الأصلية
 >>> nums
 [ 6.5 , 2.4 , 7.3 , 3.5 , 2.6 , 7.4 ]

هذا مهم جداً لأن تأثيرهما مختلف تماماً. استخدام الدالة sort() عندما كنت تنوي استخدام sorted() يمكن أن يؤدي إلى أخطاء خطيرة في برنامجك لأنك قد لا تدرك أن القائمة يتم تعديلها.

الدالة sort() تُجري ترتيباً مستقراً (Stable Sort)

الآن دعنا نتحدث قليلاً عن خصائص خوارزمية الترتيب المستخدمة بواسطة sort(). تُجري هذه الدالة ترتيباً مستقراً لأنها تعمل مع تطبيق لـ TimSort، وهي خوارزمية ترتيب فعالة ومستقرة للغاية. وفقاً لتوثيق بايثون:

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

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

 >>> d = [ "BB" , "AA" , "CC" , "A" , "B" , "AAA" , "BBB" ]
 >>> d.sort(key=len)
 >>> d
 [ 'A' , 'B' , 'BB' , 'AA' , 'CC' , 'AAA' , 'BBB' ]

نحن نقارن العناصر بناءً على طولها لأننا مررنا الدالة len كوسيط لـ key. يمكننا أن نرى أن هناك ثلاثة عناصر بطول 2: "BB" و "AA" و "CC" بهذا الترتيب. الآن، لاحظ أن هذه العناصر الثلاثة بنفس الترتيب النسبي في القائمة المرتبة النهائية:

هذا لأن الخوارزمية مضمونة لتكون مستقرة، وقد كان لكل منهم نفس القيمة الوسيطة (key) أثناء عملية الترتيب (كان طولهم 2، لذا كان مفتاحهم 2).

💡 نصيحة: حدث الشيء نفسه مع "A" و "B" (طول 1) و "AAA" و "BBB" (طول 3)، فقد تم الحفاظ على ترتيبهم الأصلي بالنسبة لبعضهم البعض.

الآن بعد أن عرفت كيف تعمل الدالة sort()، دعنا نتعمق في التعديل الموضعي (mutation) وكيف يمكن أن يؤثر على برنامجك.

التعديل الموضعي (Mutation) والمخاطر: فهم الآثار الجانبية

كما وعدنا، دعنا نرى كيف تعمل عملية التعديل الموضعي خلف الكواليس:

عندما تقوم بتعريف قائمة في بايثون، مثل هذا:

a = [ 1 , 2 , 3 , 4 ]

فإنك تنشئ كائناً في موقع ذاكرة محدد. يُسمى هذا الموقع “عنوان الذاكرة” للكائن، ويُمثل برقم صحيح فريد يُسمى id. يمكنك التفكير في id كـ “علامة” تُستخدم لتحديد مكان معين في الذاكرة:

يمكنك الوصول إلى id القائمة باستخدام الدالة id()، بتمرير القائمة كوسيط:

 >>> a = [ 1 , 2 , 3 , 4 ]
 >>> id(a)
 60501512

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

على وجه الخصوص، الدالة sort() تُعدّل القائمة. هذا مثال على تأثيرها:

هنا مثال:

 # تعريف قائمة
 >>> a = [ 7 , 3 , 5 , 1 ]
 # التحقق من الـ id الخاص بها
 >>> id(a)
 67091624
 # ترتيب القائمة باستخدام .sort()
 >>> a.sort()
 # التحقق من الـ id الخاص بها (هو نفسه، لذا القائمة هي نفس الكائن في الذاكرة)
 >>> id(a)
 67091624
 # الآن القائمة مرتبة. لقد تم تعديلها!
 >>> a
 [ 1 , 3 , 5 , 7 ]

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

هنا مثال آخر على مخاطر التعديل الموضعي داخل دالة:

 # قائمة
 >>> a = [ 7 , 3 , 5 , 1 ]
 # دالة تطبع عناصر القائمة بترتيب تصاعدي.
 >>> def print_sorted ( x ):
 x.sort()
 for elem in x:
 print(elem)
 # استدعاء الدالة بتمرير 'a' كوسيط
 >>> print_sorted(a)
 1
 3
 5
 7
 # يا للهول! تم تعديل القائمة الأصلية.
 >>> a
 [ 1 , 3 , 5 , 7 ]

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

💡 نصيحة: إذا كانت الدالة تُعدّل وسيطاً، فيجب ذكر ذلك بوضوح لتجنب إدخال أخطاء في أجزاء أخرى من برنامجك.

ملخص الدالة sort()

تسمح لك الدالة sort() بترتيب قائمة تصاعدياً أو تنازلياً. تأخذ وسيطين مخصصين بالكلمة المفتاحية فقط: key و reverse.

• يحدد reverse ما إذا كانت القائمة مرتبة تصاعدياً أو تنازلياً.
• key هي دالة تُنشئ قيمة وسيطة لكل عنصر، وتُستخدم هذه القيمة لإجراء المقارنات أثناء عملية الترتيب.

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

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

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

تُعد الدالة list.sort() في بايثون أداة أساسية وفعالة لترتيب البيانات في القوائم. يكمن جوهر قوتها في قدرتها على التعديل الموضعي (in-place mutation)، مما يوفر كفاءة في الذاكرة من خلال تجنب إنشاء قوائم جديدة. ومع ذلك، فإن هذه الميزة نفسها تتطلب فهماً عميقاً وحذراً شديداً من المطور، حيث يمكن أن تؤدي التغييرات غير المتوقعة في القائمة الأصلية إلى أخطاء يصعب تتبعها في أجزاء أخرى من البرنامج. إن التمييز الواضح بين sort() التي تُعدّل القائمة وتُرجع None، والدالة sorted() التي تُرجع قائمة جديدة مرتبة دون تعديل الأصل، هو حجر الزاوية في البرمجة الآمنة والفعالة مع هياكل البيانات في بايثون. إن استخدام الوسيط key يفتح آفاقاً واسعة لتخصيص معايير الترتيب، مما يجعلها مرنة بشكل لا يصدق للتعامل مع سيناريوهات الترتيب المعقدة، مثل ترتيب الكائنات حسب سماتها أو السلاسل النصية بطرق غير تقليدية. في النهاية، فهم هذه الفروق الدقيقة يُمكّن المبرمج من كتابة تعليمات برمجية أكثر قوة وموثوقية.