بايثون – الدوال functions

الدوال functions في بايثون تستخدم لتعريف مجموعة من الاوامر التي تمثل عملية او اجراء معين ويمكن مناداتها لاعادة تنفيذها بدلا من كتابتها مرة اخرى. مثلا نعرف مجموعة من الاوامر لحساب الضرائب بناءا على مرتب الموظفين. واذا احتجنا حساب ضرائب موظف ما، ننادي تلك الدالة.

لكي تكون ​الدوال مفيدة ويعاد استخدامها، تقبل ​الدوال مجموعة من المدخلات inputs بحيث تقوم باجراء العمليات والاوامر بناءا عن تلك المدخلات ثم تقوم بارجاع النواتج/المخرجات outputs، مثلا اذا اردنا ان نكتب ​دالة حساب الضرائب للموظفين، تكون مكونات الدالة:
​المدخلات وهي المرتب، ويكون الناتج/​المخرج هو الضريبة، ويكون الكود داخل الدالة هو حساب الضريبة على حسب الشرائح، وعادة ما نسمي الكود بداخل الدالة او الاوامر التي تقوم بعملها بجسم Body الدالة، وعندما نريد استخدام الدوال نسمي ذلك بالمناداه calling اي مناداة الدالة function calling. في بايثون تتكون الدوال عند تعريفها من مجموعة من المكونات كالاتية

• المعاملات المدخلة input parameters وهي التي نعرف ونصف بها المدخلات التي تستخدمها الدالة وهي اختيارية فقد لا تحتاج الدالة مدخلات
• اسم الدالة function_name وهو الاسم الذي نعرف به الدالة و نستطيع ان نستخدمه لمنادتها به.
• جسم الدالة function body و هي الاوامر التي تنفذها الدالة.
• ارجع return وهي امر الارجاع وهو يدل على انتهاء الدالة ويأتي بعده المتغيرات التي يتم ارجاعها وهي اختيارية (قد لا ترجع الدالة مخرجات و تكون وظيفتها هي تنفيذ مجموعة من الاوامر فقط)

قواعد الكتابة Syntax

# طريقة التعريف
def method_name ([Input Parameters]):
   # جسم الدالة(الاوامر) 
   return [result]# جملة اختيارية اذا كان هناك ناتج

# طريقة مناداة الدالة

# في حالة اذا كنا لا نريد الناتج منها او لا يوجد ناتج
method_name(inputs)
# في حالة اذا كنا نريد استخدام ناتج الطريقة فنقوم بتخزبنه في متغير 
var = method_name(inputParameters)

لنجرب مثالا لدالة تحسب الضرائب وترجع قيمتها

def calculate_taxes(salary):
  taxes = 0# نبدأ بتعريف متغير الضرائب والذي سوف نقوم بارجاعه
  
  if salary < 2000:	# اذا كان المرتب اقل من 2000
    taxes = 0 # الضرائب بصفر   

  elif salary < 4000: # عندما يكون المرتب اعلى من او يساوي 2000 واقل من 4000 
    taxes = salary * .10 # %تكون الضرائب نسبة 10
	
  elif salary < 10000: #عندما يكون المرتب اعلى من او يساوي 4000 واقل من 10000
    taxes = salary * .15; # %تكون الضرائب نسبة 15
	
  else: # اذا كانت غير ذلك اي اكبر من 10000
    taxes = salary * .20 # %تكون الضرائب نسبة 20
	
  return taxes 

تشرح الكود بالاعلى:
* اسم ​الدالة : هو calculate_taxes
* ​المعاملات المدخلة : هو salary
* جسم الدالة: هو كل الكود ما بين حدود الدالة الى كلمة return
* الارجاع : هو taxes حيث ان taxes تحتوي على ناتج الارجاع.

ويكون طريقة نداء/​​مناداة ​الدالة بالاعلى كالاتي:

# الموظف الاول مرتبه يساوي 8000
employee_salary_a = 8000
# ننادي على دالة حساب الضرائب
employee_taxes_a = calculate_taxes(employee_salary_a) # %الراجع يكون 1200 وهو نسبة 15
print(employeeTaxesA)
# الموظف الاول مرتبه يساوي 20000
employee_salary_b = 20000;
# ننادي على دالة حساب الضرائب
employee_taxes_b = calculate_taxes(employee_salary_b) # %الراجع يكون 4000 وهو نسبة 20
print(employee_taxes_b)

ملحوظة: عندما نادينا ​الدالة لم يكن اسم ​المتغير الذي ادخلنا مثل الموجود عند تعريف الدالة، لان هذا ليس شرطا.

يجب ان تكون عدد المدخلات التي نمررها الى الدالة يساوي عدد المعاملات المدخلة عند تعريف الدالة.

المعاملات المدخلة الافتراضية Default Input Parameters

تمكننا بايثون من تعريف قيم افتراضية للمدخلات في حالة اذا لم نمرر قيمة للمعاملات عند ​مناداة الدوال

# name نعرف قيمة افتراضية ل
def show_info(age, name="Mohammad"):
    print(name +" has: "+ str(age) + "years old")
    return
    
# name ننادي الدالة بدون تمرير المدخل     
show_info(17)

# ننادي الدالة بتمرير كل المدخلات
show_info(17,"Ahmad")

ملجوظة: عدد المدخلات عند مناداة الدلة في الحالة الاولى هي 1 فقط و هو اقل من عدد المعاملات عند تعريف الدالة وذلك لتعريف قيمة افتراضية للمتغيرات 

نستطيع تعريف اكثر من مدخل بقيم افتراضيةن لكن يجب ان تكون المدخلات الاخيرة في التعريف.

المدخلات باسماء المعاملات

قد تحتوي الدالة على اكثر من ​معاملات مدخلة وعند منادتها يجب ان نمرر المدخلات على حسب ترتيب المعاملات المقابلة لها

def fun(x,y):
    print (x)
    print (y)
    return

# x => 5 & y => 7
fun(5,7)

نكمننا البايثون من استخدام اسماء ​المعاملات عند ​المناداة، بمعنى اننا قد لا نلتزم بترتيب تعريف المعاملات في الدالة. لكن عند تمرير ​المدخلات نمرر اسم المعاملات معها

def fun(x,y):
    print (x)
    print (y)
    print("----------")
    return

# x => 5 & y => 7
fun(5,7)
# نفس نتيجة المناداه السابقة
fun(x=5,y=7)
# نفس نتيجة المناداه السابقة
fun(y=7, x=5)

args*

تمكننا البايثون من تمرير عدد غير محدد من ​المدخلات عن طريق استخدام الرمز * قبل اخر معامل ادخال يتم تعريفه، حيث يكون هذا المعامل tuple يحتوي على كل القيم التي يتم تمريرها، مثال نريد ان نجمع كل الارقام التي نمررها للدالة

def sum_all(message, *numbers): 
    print (message) 
    sum = 0
    for num in numbers:
        sum = sum + num
    
    return sum
    
    
sum_1 = sum_all('sum_1:', 1,5,6,7)
print(sum_1) # 19
sum_2 = sum_all('sum_2:', 3,3)
print(sum_1) # 6

args**

تمكننا البايثون من تمرير عدد غير محدد من ​المدخلات ايضا عن طريق استخدام الرمز ** قبل اخر معامل ادخال يتم تعريفه، لكن يكون هذا المعامل من نوع Dictionary ، لذلك عند منادة الدالة يجب ان نمرر معامل وقيمة!!

def print_student_grades(**grades):

    print(grades["Ahmad"])
    print(grades["Mohammad"])
    return
    
print_student_grades(Ahmad=25,Mohammad=49)