الدليل الشامل لدالة الماب في بايثون لمعالجة البيانات

مقدمة

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

الصيغة المستخدمة لدالة map() هي كما يلي:

map(function, iterable, [iterable 2, iterable 3, ...])

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

في هذا الدليل، سنستعرض ثلاث طرق مختلفة للعمل مع map(): باستخدام دالة lambda، باستخدام دالة معرفة من قبل المستخدم، وأخيراً باستخدام دالة مدمجة تتضمن عدة وسائط قابلة للتكرار.

استخدام دالة لامدا

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

تكون صيغة map() مع دالة لامدا كما يلي:

map(lambda item: item[] expression, iterable)

مع قائمة مثل القائمة التالية، يمكننا تنفيذ دالة lambda مع تعبير نريد تطبيقه على كل عنصر في قائمتنا:

numbers = [10, 15, 21, 33, 42, 55]

لتطبيق تعبير على كل أرقامنا، يمكننا استخدام map() و lambda:

mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))

هنا نعلن عن عنصر في قائمتنا باسم x. ثم نضيف تعبيرنا. نمرر قائمتنا من الأرقام كوسيط قابل للتكرار لـ map().

لكي نحصل على نتائج هذا على الفور، نطبع قائمة كائن map:

print(mapped_numbers)

Output
[23, 33, 45, 69, 87, 113]

لقد استخدمنا list() حتى يتم إرجاع كائن الخريطة لنا كقائمة، بدلاً من كائن أقل قابلية للقراءة مثل: <map object at 0x7fc250003a58>. كائن الخريطة هو متكرر على نتائجنا، لذلك يمكننا أن ندور عليه باستخدام for أو يمكننا استخدام list() لتحويله إلى قائمة. نحن نفعل ذلك هنا لأنه طريقة جيدة لمراجعة النتائج.

في النهاية، map() يكون أكثر فائدة عند العمل مع مجموعات بيانات كبيرة، لذا من المحتمل أن نعمل مع كائن الخريطة بشكل أكبر، وعادةً لن نستخدم منشئًا مثل list() عليها.

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

تنفيذ دالة معرّفة من قبل المستخدم

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

على سبيل المثال، في المتكرر التالي، يحتوي كل عنصر على قاموس يحتوي على تفاصيل مختلفة عن كل من مخلوقات حوض السمك لدينا:

aquarium_creatures = [
 {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
 {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
 {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
 {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
 {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
 {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
]

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

def assign_to_tank(aquarium_creatures, new_tank_number):
 def apply(x):
  x["tank number"] = new_tank_number
  return x
 return map(apply, aquarium_creatures)

نعرف دالة assign_to_tank() التي تأخذ aquarium_creatures وnew_tank_number كمعاملات. في assign_to_tank() نمرر apply() كالدالة إلى map() في السطر الأخير. ستعيد دالة assign_to_tank المكرر الناتج من map().

apply() تأخذ x كوسيط، والذي يمثل عنصرًا في قائمتنا – قاموسًا واحدًا.

بعد ذلك نحدد أن x هو مفتاح "tank number" من aquarium_creatures وأنه يجب أن يخزن new_tank_number الممرر. نعيد كل عنصر بعد تطبيق رقم الخزان الجديد.

ندعو assign_to_tank() مع قائمتنا من القواميس ورقم الخزان الجديد الذي نريد استبداله لكل كائن:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

بمجرد اكتمال الدالة، لدينا كائن الخريطة مخزن في متغير assigned_tanks، والذي نحوله إلى قائمة ونقوم بطباعته:

print(list(assigned_tanks))

سنتلقى الناتج التالي من هذا البرنامج:

Output
[{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

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

استخدام دالة مدمجة مع عدة تكرارات

بنفس الطريقة التي نستخدم بها دوال lambda أو الدوال المعرفة من قبلنا، يمكننا استخدام الدوال المدمجة في بايثون مع map(). لتطبيق دالة مع عدة تكرارات، نقوم بتمرير اسم تكرار آخر بعد الأول. على سبيل المثال، باستخدام دالة pow() التي تأخذ رقمين لإيجاد قوة الرقم الأساسي بالنسبة للأس exponent المقدم.

هنا لدينا قوائمنا من الأعداد الصحيحة التي نرغب في استخدامها مع pow():

base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]

بعد ذلك، نقوم بتمرير pow() كدالتنا إلى map() وتوفير القائمتين كتكراراتنا:

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

map() ستطبق دالة pow() على نفس العنصر في كل قائمة لتوفير القوة. لذلك ستظهر نتائجنا 2**1، 4**2، 6**3، وهكذا:

Output
[2, 16, 216, 4096, 100000]

إذا كنا سنقدم لـ map() تكرارًا أطول من الآخر، ستتوقف map() عن حساب القيم بمجرد الوصول إلى نهاية التكرار الأقصر. في البرنامج التالي، نقوم بتمديد base_numbers بثلاثة أرقام إضافية:

base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
powers = [1, 2, 3, 4, 5]

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

نتيجة لذلك، لن يتغير شيء داخل عملية حساب هذا البرنامج وبالتالي سيستمر في إعطاء نفس النتيجة:

Output
[2, 16, 216, 4096, 100000]

لقد استخدمنا وظيفة map() مع وظيفة مدمجة في لغة Python ورأينا أنها يمكنها التعامل مع عدة متكررات. كما قمنا بمراجعة أن map() سيستمر في معالجة عدة متكررات حتى يصل إلى نهاية المتكرر الذي يحتوي على أقل عدد من العناصر.

الاستنتاج

في هذا البرنامج التعليمي، استكشفنا طرق مختلفة لاستخدام وظيفة map() في لغة Python. لديك الآن القدرة على استخدام map() مع الوظائف المخصصة، تعبيرات lambda، والوظائف المدمجة الأخرى. بالإضافة إلى ذلك، يمكن تطبيق map() على الوظائف التي تتطلب عدة متكررات، مما يعزز مرونته في مهام معالجة البيانات.

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

لتعميق فهمك للغة Python، يرجى استخدام الموارد التالية:

• دليل وظيفة map() في Python لمزيد من الأمثلة التفصيلية والحالات الاستخدامية.
• فهم القواميس في بايثون لتعزيز معرفتك بهياكل البيانات في بايثون.
• دوال السلاسل في بايثون لاستكشاف تقنيات مختلفة لمعالجة السلاسل.

ستوفر لك هذه الموارد فهمًا شاملاً لإمكانات بايثون وكيفية استخدامها بشكل فعال في مشاريعك.

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

الأسئلة الشائعة

ماذا تفعل الدالة map() في بايثون؟

تأخذ دالة map() في بايثون دالة وواحد أو أكثر من المجموعات القابلة للتكرار وتعيد مكررًا يطبق الدالة المعطاة على كل عنصر من العناصر في المجموعات المقدمة. بعبارة أخرى، تقوم “بخريطة” الدالة عبر كل عنصر في المجموعة القابلة للتكرار. على سبيل المثال:

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)

هنا، ستكون squares مكررًا لـ 1، 4، 9، 16.

كيف تنشئ خريطة في بايثون؟

تقوم بإنشاء كائن خريطة عن طريق استدعاء الدالة المدمجة map() مع دالة وواحد على الأقل من المجموعات القابلة للتكرار كوسائط. على سبيل المثال:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # ينشئ كائن خريطة

يمكنك بعد ذلك التكرار على الخريطة أو تحويلها إلى قائمة لرؤية النتائج:

print(list(mapped))  # [2، 3، 4]

هل الخريطة كسولة في بايثون؟

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

كيف تعمل وظيفة map()؟

تعمل وظيفة map() على النحو التالي:

1. توفر وظيفة واحدة أو أكثر ومتغيرات قابلة للتكرار.
2. map() يسترد عنصرًا من كل متغير قابل للتكرار.
3. يقوم بنداء الوظيفة باستخدام هذه العناصر كوسائط.
4. ينتج نتيجة نداء تلك الوظيفة.
5. يكرر هذه العملية حتى يتم استنفاذ أي من المتغيرات القابلة للتكرار.

إذا تم توفير متغيرات قابلة للتكرار متعددة، يتوقف map() عند استنفاذ أقصر متغير قابل للتكرار. على سبيل المثال:

numbers = [1, 2, 3]
others = [10, 20, 30]
result = map(lambda x, y: x + y, numbers, others)
print(list(result))  # [11, 22, 33]

هل يجب علي استخدام map في Python؟

ما إذا كان يجب عليك استخدام map() يعتمد على التفضيل الشخصي والقراءة:

الإيجابيات:

• قد تكون أكثر إيجازًا في بعض الحالات.
• قد تكون أسرع قليلاً من القوائم التكميلية في بعض السيناريوهات (على الرغم من أنها غالبًا ليست بشكل كبير).

السلبيات:

• يُعتبر الكود الذي يستخدم القوائم التكميلية أو التعبيرات المولدة عادةً أكثر “بايثونية” وأكثر قراءةً سهولةً.
• قد يجد المبرمجون الجدد بلغة بايثون أن فهم القوائم المفهومة أكثر سهولة.

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

كيف تقوم بتحويل map إلى سلسلة نصية في بايثون؟

كائن map هو مكرر، وليس سلسلة نصية. إذا كنت تريد تحويل نتائج استدعاء map() إلى سلسلة نصية، تحتاج أولاً إلى التكرار عليها. الطرق الشائعة تشمل:

• التحويل إلى قائمة ثم إلى تمثيل نصي:

mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"

• دمج النتائج إذا كانت عناصر نصية:

mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

أفضل طريقة تعتمد على ما إذا كنت تريد تمثيل قائمة مقروءة من قبل الإنسان (str(list(...))) أو دمج النتائج (''.join(...)).

ماذا تفعل map count()؟

أجسام map في بايثون لا تحتوي على طريقة count() مدمجة. تتوفر طريقة count() على القوائم، والسلاسل، وبعض المجموعات الأخرى. إذا كنت تريد عد occurrences لقيمة تنتجها جسم map، يجب عليك أولاً تحويلها إلى قائمة (والتي تستهلك المكرر):

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2، لأن 2*2=4 يظهر مرتين

إذا كنت بحاجة إلى عد بدون تحويل إلى قائمة، يمكنك التكرار يدويًا:

count_of_value = sum(1 for x in map(lambda x: x*2, [1, 2, 3, 2]) if x == 4)

ما الذي تفعله map و filter في بايثون؟

• map(function, iterable): تطبق الوظيفة على كل عنصر من iterable وتعيد مكررًا للنتائج.

• filter(function, iterable): تعيد مكررًا للعناصر من iterable التي تكون فيها function(element) صحيحة. إذا كانت الوظيفة None، تعيد العناصر التي تكون صحيحة بمفردها.

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

nums = [1, 2, 3, 4, 5]
mapped_nums = map(lambda x: x*2, nums)        # [2, 4, 6, 8, 10]
filtered_nums = filter(lambda x: x > 2, nums) # [3, 4, 5]

map يقوم بتحويل كل عنصر، بينما filter يختار بعض العناصر بناءً على شرط.