الدوال الرياضية المضمنة في بايثون 3

تتضمّن بايثون 3 العديد من الدوال التي يمكنك استخدامها بسهولة في أي برنامج. تتيح لك بعض تلك الدوال تحويل أنواع البيانات، والبعض الآخر خاص بنوع معين، مثل السلاسل النصية.

سنستعرض في هذه المقالة بعض الدوال الرياضية المُضمّنة التي يمكن استخدامها مع أنواع البيانات العددية في بايثون 3. سنلقي نظرة على الدوال التالية:

abs()‎: للحصول على القيمة المطلقة
divmod()‎: للحصول على الحاصل والباقي في وقت واحد
pow()‎: لرفع عدد لقوة معينة
round()‎: لتقريب عدد بمنازل عشرية محددة
sum()‎: لحساب مجموع العناصر في كائن قابلٍ للتكرار (iterable)

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

القيمة المطلقة

تعيد الدالة المضمّنة abs()‎ القيمة المطلقة للعدد الذي يُمرر إليها. في الرياضيات، تشير القيمة المطلقة إلى العدد نفسه إن كانت القيمة موجبة، أو القيمة المعاكسة إن كانت القيمة سالبة.

مثلًا، القيمة المطلقة للعدد 15 هي 15، والقيمة المطلقة للعدد ‎-74 هي 74، والقيمة المطلقة للعدد 0 هي 0.

القيمة المطلقة مفهوم مهم في الحساب والتحليل، كما أنّها مفيدة كذلك في المواقف اليومية، مثل حساب المسافة المقطوعة. على سبيل المثال، إذا كنت تحاول الوصول إلى مكان يبعد 58 ميلًا، ولكنك تجاوزت ذلك المكان، وسافرت 93 فرسخًا. فإن حسبت عدد الفراسخ التي ينبغي أن تقطعها الآن للوصول إلى الوجهة المقصودة، فسوف ينتهي بك المطاف بعدد سالب، لكن لا يمكنك السفر عددًا سالبًا من الفراسخ!

سنستخدم الدالة abs()‎ لحل هذه المشكلة:

miles_from_origin = 58   # عدد الفراسخ التي تفصلنا عن الوجهة انطلاقًا من المُنطلق 
miles_travelled = 93       # الفراسخ المقطوعة من المُنطَلق إلى الوجهة

# حساب عدد الفراسخ من الموقع الحالي
miles_to_go = miles_from_origin - miles_travelled   

print(miles_to_go)            # طباعة عدد الفراسخ المتبقية - عدد سالب
print(abs(miles_to_go))    # حساب القيمة المطلقة للعدد السالب

المخرجات ستكون:

-35
35

لولا استخدام الدالة abs()‎، لحصلنا على عدد سالب، أي ‎-35. ورغم أنّ miles_travelled أصغر من miles_from_origin، فإنّ الدالة abs()‎ تحل إشكالية العدد السالب.

عندما نمرّر لها عددًا سالبًا، ستعيد الدالة abs()‎ عددًا موجبًا، لأنّ القيمة المطلقة دائمًا تعيد أعدادًا موجبة أو معدومة.

في المثال التالي، سنمرر للدالة abs()‎ عددًا موجبًا، وكذلك الصفر:

print(abs(89.9))     #  89.9 
print(abs(0))          # 0

العثور على الحاصل والباقي بدالة واحدة

القسمة التحتية (floor division، التي تُعيد حاصل القسمة [quotient])، وقسمة الباقي (modulo division، التي تعيد باقي القسمة [remainder])، مرتبطان ارتباطًا وثيقًا، وقد يكون من المفيد استخدام دالة تجمع بين العمليتين معًا.

تجمع الدالة المضمّنة divmod()‎ بين العمليتين، إذ تعيد أولًا حاصل عملية القسمة التحتية، ثم الباقي. ينبغي تمرير عددين إلى الدالة divmod()‎، على النحو التالي:

divmod(a,b)

تكافئ هذه الدالة العمليتين التاليتين:

a // b
a & b

لنفترض أننا كتبنا كتابًا يحتوي 80 ألف كلمة. يريد الناشر أن تحتوي كل صفحة من الكتاب ما بين 300 و 250 كلمة، ونود أن نعرف عدد الصفحات التي ستشكل الكتاب بحسب عدد كلمات الصفحة الذي اخترناه. باستخدام الدالة divmod()‎، يمكننا أن نعرف على الفور عدد الصفحات في الكتاب، وعدد الكلمات المتبقية التي ستُنقل إلى صفحة إضافية.

words = 80000     # كم عدد الكلمات في كتابنا
per_page_A = 300    # 300 عدد كلمات الصفحة هو :A الخيار
per_page_B = 250    # عدد كلمات الصفحة هو 250 :B الخيار 

print(divmod(words,per_page_A)) # A حساب الخيار
print(divmod(words,per_page_B)) # B حساب الخيار

وسينتج عن هذه الشيفرة:

(266, 200)
(320, 0)

في الخيار A، سنحصل على 266 صفحة مليئة بالكلمات، و 200 كلمة متبقية (ثلثا صفحة)، والمجموع هو 267 صفحة، وفي الخيار B، سنحصل على كتاب من 320 صفحة. إن أردنا الحفاظ على البيئة، فالخيار A قد يكون أفضل، ولكن إذا أردنا تصميمًا جذابًا، أو الكتابة بحجم خط كبير، فقد نختار الخيار "B".

تقبل الدالة divmod()‎ االأعداد الصحيحة والأعداد العشرية، في المثال التالي سنمرر عددًا عشريًّا إلى الدالة divmod()‎:

a = 985.5
b = 115.25

print(divmod(a,b))   #  (8.0, 63.5)

في هذا المثال، العدد 8.0 هو حاصل القسمة التحتية للعدد 985.5 مقسومًا على 115.25، و 63.5 هو الباقي.

يمكنك استخدام عامل القسمة التحتية // و عامل الباقي% للتحقق من نتيجة divmod()‎:

print(a//b)   #  8.0
print(a%b)   # 63.5

القوة (Power)

في بايثون، يمكنك استخدام عامل القوة ** (أو الأس) لرفع عدد إلى قوة معينة، أو يمكنك استخدام الدالة pow()‎ المضمّنة التي تأخذ عددين وتجري العملية نفسها.

لتوضيح كيفية عمل الدالة pow()‎، لنقل أننا نجري أبحاثًا على البكتيريا، ونريد أن نقدّر عدد البكتيريا التي سنحصل عليها في نهاية اليوم إذا بدأنا ببكتيريا واحدة. تتضاعف البكتيريا التي نعمل عليها في كل ساعة، لذلك النتيجة النهائية ستكون 2 قوة العدد الكلي لعدد الساعات التي مرت (24 في حالتنا).

hours = 24
total_bacteria = pow(2,hours)

print(total_bacteria)   # 16777216

لقد مرّرنا عددين صحيحين للدالة pow()‎، والنتيجة التي حصلنا عليها، والتي تمثِّل عدد البكتيريا بحلول نهاية اليوم، هي أكثر من 16 مليون بكتيريا.

في الرياضيات، نكتب "3 أسّ 3" بشكل عام على النحو التالي: 3^³ والتي تكافئ 3 × 3 × 3، أي 27. ولحساب 3^³ في بايثون، نكتب pow(3,3)‎. تقبل الدالة pow()‎ الأعداد الصحيحة والأعداد العشرية، وتوفّر بديلًا لعامل الأس **.

تقريب الأعداد

تقريب الأعداد (Rounding Numbers) ضروري عند العمل مع الأعداد العشرية التي تحتوي على الكثير من المنازل (الأجزاء) العشرية. تقبل الدالة المضمنة round()‎ عددين: أحدها يمثِّل العدد المراد تقريبه والآخر يحدّد عدد المنازل العشرية المراد الإبقاء عليها (أي قيمة التقريب).

سنستخدم هذه الدالة لتقريب عدد عشري له أكثر من 10 منازل عشرية والحصول على عدد بأربعة منازل عشرية فقط:

i = 17.34989436516001
print(round(i,4))   # 17.3499

في المثال أعلاه، تم تقريب العدد 17.34989436516001 إلى 17.3499 لأننا حددنا عدد المنازل العشرية التي ينبغي الاقتصار عليها بأربعة.

لاحظ أيضًا أنّ الدالة round()‎ تقرّب الأعداد إلى الأعلى، لذا بدلًا من إعادة 17.3498، فقد أعادت 17.3499، لأنّ الرقم الذي يلي المنزل العشري 8 هو الرقم 9. وسيتم تقريب أي عدد متبوع بالعدد 5 أو أكبر إلى العدد الصحيح التالي.

في الحياة اليومية، نُقرِّب الأعداد لأسباب كثيرة، وخاصة في التعاملات المالية؛ فلا يمكننا تقسيم فلس واحد بالتساوي بين عدة أصدقاء مثلًا.

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

bill = 87.93                   # إجمالي الفاتورة
tip = 0.2                      # ٪ 20 بقشيش
split = 3                      # عدد الناس الذين سيتشاركون الفاتورة

total = bill + (bill * tip)    # حساب الفاتورة الإجمالية
each_pay = total / split       # حساب ما ينبغي أن يدفعه كل شخص
print(each_pay)                # ما ينبغي أن يدفعه كل شخص قبل التقريب
print(round(each_pay,2))       # تقريب العدد - لا يمكننا تقسيم الفلسات

والمخرجات ستكون:

35.172000000000004
35.17

في هذا البرنامج، نطلب أولًا إخراج العدد بعد حساب إجمالي الفاتورة والإكراميات مقسومًا على 3، النتيجة ستكون عددًا يتضمّن الكثير من المنازل العشرية: 35.172000000000004. نظرًا لأنّ هذا العدد ليس له معنى كمبلغ مالي، فإننا نستخدم الدالة round()‎، ونقصر المنازل العشرية على 2، حتى نتمكن من توفير ناتج يمكن للأصدقاء الثلاثة أن يدفعوه: 35.17.

إذا كنت تفضل التقريب إلى عدد بلا منازل عشرية، يمكنك تمرير 0 كمعامل ثان إلى الدالة round()‎:

round(345.9874590348545304636,0)

القيمة الناتجة ستكون 346.0.

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

حساب المجموع

تُستخدم الدالة sum()‎ لحساب مجاميع أنواع البيانات العددية المركبة (numeric compound data types)، بما في ذلك القوائم، والصفوف، والقواميس.

يمكننا تمرير قائمة إلى الدالة sum()‎ لجمع كل عناصرها بالترتيب من اليسار إلى اليمين:

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]
print(sum(some_floats))    #  49.5

نفس النتيجة سنحصل عليها إن استخدمنا الصفوف والقواميس:

print(sum((8,16,64,512)))  # حساب مجموع الأعداد في الصف
print(sum({-10: 'x', -20: 'y', -30: 'z'}))  # حساب مجموع الأعداد في القاموس

المخرجات:

60
-60

يمكن أن تأخذ الدالة sum()‎ وسيطين، الوسيط الثاني سيُضاف إلى المجموع الناتج:

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]

print(sum(some_floats, 0.5))                     # 50.0
print(sum({-10: 'x', -20: 'y', -30: 'z'},60))    # 0