10 تمارين تدريبية على الدوال في بايثون للمبتدئين

تتيح لك الدوال تغليف التعليمات البرمجية في كتل قابلة لإعادة الاستخدام ومنظمة، مما يجعل برامجك أكثر قابلية للتعديل والصيانة. مع بدء مسيرتك المهنية في البرمجة، فإن إتقان دوال بايثون يعد خطوة بالغة الأهمية في رحلتك. ولمساعدتك على الوصول إلى هناك، قمنا بتنظيم 10 تمارين تدريبية على دوال بايثون مصممة خصيصًا للمبتدئين.

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

كيف تعمل دوال بايثون

قبل القفز إلى تمارين دوال بايثون، دعنا نلقي نظرة سريعة على كيفية عمل دوال بايثون.

لتعريف دالة نكتب العناصر التالية في سطر واحد:

• def
• اسم الدالة (والتي يمكننا اختيارها بحرية).
• معلمات الدالة داخل الأقواس (اترك الأقواس فارغة إذا لم تكن هناك معلمات).
• نقطتان (:) في النهاية.

وهذا ما يبدو عليه الأمر:

def function_name(parameter1, parameter2):

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

فيما يلي مثال أساسي لدالة تسمى sum_values ​​تأخذ وسيطتين (a وb) وترجع مجموعهما:

def sum_values(a, b):
    result = a + b
    return result
 
# Calling the function for testing
print(sum_values(1, 2))
 
# output:
# 3

تمرين 1 في دالة بايثون: طباعة جملة عدة مرات

لنبدأ ببساطة: اكتب دالة بايثون تطلب من المستخدم إدخال رقم. ثم، عند إدخال هذا الرقم، تطبع الجملة “Hello, Python!” عدة مرات.

الحل

def print_sentence_multiple_times():
    num = int(input("Enter a number: "))
    for _ in range(num):
        print("Hello, Python!")
 
 
print_sentence_multiple_times()
 
# output: (input = 3)
# Hello, Python!
# Hello, Python!
# Hello, Python!

الشرح

في الدالة print_sentence_multiple_times()، نطالب المستخدم بإدخال رقم باستخدام الدالة input(). ثم نحول المدخلات إلى عدد صحيح باستخدام int(). بعد ذلك، يتم استخدام حلقة for لتكرار هذا العدد من المرات، وطباعة الجملة “Hello, Python!” في كل تكرار.

لاحظ أننا نستخدم _ كاسم متغير في حلقة for. هذه اتفاقية بايثون تشير إلى أن اسم المتغير ليس مهمًا – في الواقع، لا نحتاج أبدًا إلى استخدامه في حلقة for هذه!

تمرين 2 في دالة بايثون: حساب عدد الأحرف الكبيرة والصغيرة

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

الحل

def count_upper_lower_chars(input_string):
    char_count = {"uppercase": 0, "lowercase": 0, "other": 0}
    for char in input_string:
        if char.isupper():
            char_count["uppercase"] += 1
        elif char.islower():
            char_count["lowercase"] += 1
        else:
            char_count["other"] += 1
    return char_count
 
sentence = "Hello, Python! How are you?"
result = count_upper_lower_chars(sentence)
 
print(result)
 
# output:
# {'uppercase': 3, 'lowercase': 17, 'other': 7}

الشرح

تأخذ الدالة count_upper_lower_chars() سلسلة نصية input_string كمدخل وتنشئ قاموس char_count لتخزين عدد الأحرف الكبيرة والصغيرة والرموز (“أخرى”). ثم تتكرر على كل حرف في سلسلة الإدخال. لكل حرف، نختبر ما إذا كان كبيرًا أم صغيرًا، ونزيد القيمة المقابلة في قاموس char_count. إذا لم يكن أيًا منهما، يتم زيادة عدد الأحرف الأخرى بدلاً من ذلك. أخيرًا، يتم إرجاع قاموس char_count.

تمرين دالة بايثون 3: إيجاد أقصر وأطول الكلمات

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

الحل

def shortest_longest_words(words_list):
    shortest_word = min(words_list, key=len)
    longest_word = max(words_list, key=len)
    return shortest_word, longest_word
 
words = ["apple", "banana", "kiwi", "grapefruit", "orange"]
result = shortest_longest_words(words)
 
print(result)
 
# output:
# ('kiwi', 'grapefruit')

الشرح

تأخذ الدالة shortest_longest_words() قائمة من سلاسل الكلمات words_list كمدخل وتستخدم الدالتين min() وmax() للعثور على أقصر وأطول الكلمات. لكي يعمل هذا، نضبط معلمة المفتاح على الدالة len، مما يعني أنه سيتم مقارنة الكلمات حسب أطوالها.

ماذا لو كان هناك عدة مرشحين لأقصر أو أطول كلمة؟ تقوم الدالتان min() وmax() بالفعل بإرجاع العنصر الأول، لذا لا يوجد شيء يمكن تعديله حقًا.

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

تمرين رقم 4 في دالة بايثون: التحقق قبل الإضافة

اكتب دالة بايثون تأخذ قائمة وعنصرًا كمدخلات. يجب أن تضيف الدالة العنصر إلى القائمة فقط إذا لم يكن موجودًا بالفعل في القائمة.

الحل

def add_unique_element(input_list, element):
    if element not in input_list:
        input_list.append(element)
 
my_list = ["apple", "banana", "kiwi"]
add_unique_element(my_list, "banana")
add_unique_element(my_list, "orange")
 
print(my_list)
 
# output:
# ['apple', 'banana', 'kiwi', 'orange']

الشرح

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

تمرين رقم 5 على دالة بايثون: إزالة التكرارات والفرز

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

الحل

def remove_duplicates_and_sort(input_list):
    unique_sorted_list = sorted(set(input_list))
    return unique_sorted_list
 
input_list = ["apple", "banana", "kiwi", "banana", "orange", "apple"]
result = remove_duplicates_and_sort(input_list)
 
print(result)
 
# output:
# ['apple', 'banana', 'kiwi', 'orange']

الشرح

تأخذ الدالة remove_duplicates_and_sort() قائمة السلاسل input_list كمدخلات. ثم تعمل في عملية من خطوتين:

• أولاً، تقوم بإنشاء مجموعة من قائمة الإدخال باستخدام set(input_list). نظرًا لأن مجموعات بايثون لا تحتوي على أي تكرارات، فإن هذا يزيل تلقائيًا الإدخالات المكررة من القائمة.
• بعد ذلك، يتم فرز العناصر الفريدة باستخدام sorted()

نظرًا لأن sorted() تعيد دائمًا قائمة، فقد انتهينا بالفعل! كل ما تبقى هو إرجاع القائمة.

تمرين الدالة في بايثون 6: العثور على التواجد الثاني

اكتب دالة بايثون تأخذ قائمة وعنصرًا كمدخلات. يجب أن تعيد الدالة مؤشر الظهور الثاني للعنصر في القائمة. إذا كان هناك أقل من ظهورين، فيجب أن تعيد الدالة -1.

الحل

def second_occurrence_index(input_list, element):
    occurrences = []
    for index in range(len(input_list)):
        if input_list[index] == element:
            occurrences.append(index)
 
    if len(occurrences) < 2:
        return -1
    else:
        return occurrences[1]
 
my_list = ["apple", "banana", "kiwi", "banana", "orange", "banana"]
element = "banana"
index = second_occurrence_index(my_list, element)
 
print(f"Index of the second occurrence of {element}: {index}")
 
# output:
# Index of the second occurrence of banana: 3

الشرح

تتكرر الدالة second_occurrence_index() خلال القائمة باستخدام حلقة for مع نطاق طول القائمة. بهذه الطريقة، نكرر كل مؤشر ممكن للقائمة. لكل مؤشر، تتحقق الدالة مما إذا كان العنصر عند هذا المؤشر يتطابق مع عنصر الإدخال. عندما تكون هذه هي الحالة، يتم إلحاق المؤشر بقائمة الأحداث.

بمجرد انتهاء حلقة for، تتحقق الدالة ما إذا كان طول التكرارات أقل من 2. إذا كان الأمر كذلك، فهذا يعني أنه لم يكن هناك أي تكرار أو تكرار واحد، لذا يجب علينا إرجاع -1. وإلا، فإنها ترجع مؤشر التكرار الثاني، والذي يتم تخزينه في قائمة التكرارات عند المؤشر 1.

تمرين الدالة في بايثون 7: فرز الأرقام غير السالبة

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

الحل

def sort_non_negative_numbers(input_list):
    non_negative_numbers = []
    for num in input_list:
        if num >= 0:
            non_negative_numbers.append(num)
    sorted_non_negative_numbers = sorted(non_negative_numbers)
    return sorted_non_negative_numbers
 
numbers = [5, -3, 0, 9, -2, 7, -1, 4]
result = sort_non_negative_numbers(numbers)
 
print(result)
 
# output:
# [0, 4, 5, 7, 9]

الشرح

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

بعد تكرار قائمة الإدخال بالكامل، نقوم بفرز قائمة الأرقام غير السلبية باستخدام الدالة sorted(). ثم نقوم بإرجاع القائمة المفرزة الناتجة، والتي تحتوي فقط على الأرقام غير السلبية.

تمرين الدالة في بايثون 8: حساب قيمة الكلمة

اكتب دالة بايثون تأخذ كلمة كمدخل وتعيد “القيمة” المحسوبة لها، بناءً على القواعد التالية:

• الحروف الساكنة تساوي نقطة واحدة.
• الحروف المتحركة تستحق 3 نقاط.
• الحرف “x” يساوي 10 نقاط.
• أية أحرف أخرى تستحق 0 نقطة.

الحل

def calculate_word_value(word):
    value = 0
    for char in word:
        if char.lower() in 'aeiou':
            value += 3
        elif char.lower() == 'x':
            value += 10
        elif char.isalpha():
            value += 1
    return value
 
word = "Python"
result = calculate_word_value(word)
 
print(result)
 
# output:
# 8

شرح

تأخذ الدالة calculate_word_value() كلمة كمدخل وتحدد قيمة المتغير. يخزن هذا المتغير القيمة المحسوبة للكلمة، بدءًا من 0. ثم نكرر كل حرف في الكلمة باستخدام حلقة for.

بالنسبة لكل حرف، نتحقق مما إذا كان حرفًا متحركًا (باستخدام السلسلة “aeiou”)، أو الحرف “x”، أو حرفًا ساكنًا (باستخدام التابع str.isalpha()). بناءً على نوع الحرف، نضيف النقاط المقابلة إلى القيمة. في النهاية، نعيد القيمة المحسوبة للكلمة.

تمرين الدالة في بايثون 9: تحويل الأحرف في الأبجدية

اكتب دالة بايثون تأخذ سلسلة كمدخل وتعيد سلسلة جديدة حيث يتم إزاحة كل حرف بمقدار حرف واحد في الأبجدية. على سبيل المثال، يصبح “A” “B”، ويصبح “B” “C”، وهكذا.

الحل

def shift_characters(input_string):
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    shifted_string = ""
    for char in input_string:
        if char.isalpha():
            shifted_char_idx = (alphabet.index(char.lower()) + 1) % 26
            shifted_char = alphabet[shifted_char_idx]
            if char.isupper():
                shifted_string += shifted_char.upper()
            else:
                shifted_string += shifted_char
        else:
            shifted_string += char
    return shifted_string
 
sentence = "Hello, Python!"
result = shift_characters(sentence)
print(result)
 
# output:
# Ifmmp, Qzuipo!

الشرح

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

تبدأ الدالة shift_characters() بأخذ input_string كمدخل. في الدالة، نقوم بتخزين سلسلة الأبجدية التي تحتوي على جميع الأحرف الصغيرة. يتم إنشاء سلسلة فارغة تسمى shifted_string لتخزين الأحرف المحولة.

ثم نكرر كل حرف في سلسلة الإدخال. لكل حرف، يتم التحقق مما إذا كان حرفًا باستخدام char.isalpha(). إذا لم يكن الحرف حرفًا، ينتقل الكود إلى جملة else ويضيف ببساطة char إلى shifted_string، مما يعني أن الرموز والمسافات تظل دون تغيير.

إذا كان الحرف حرفًا، فنحن بحاجة إلى معرفة ما نضيفه إلى shifted_string – أي الحرف التالي في الأبجدية. للقيام بذلك، نحصل أولاً على مؤشر الحرف المحول في الأبجدية، shifted_char_idx. يتم ذلك باستخدام alphabet.index() للحصول على مؤشر الحرف الحالي (مع char.lower() لتجاهل حالة الأحرف). نضيف قيمة 1 إلى المؤشر للحصول على مؤشر الحرف التالي. لاحظ أننا نستخدم عامل modulo ( % ) بحيث يلتف المؤشر الناتج حوله، مما يتجنب حدوث خطأ IndexError المحتمل. يتم إنجاز كل هذا في سطر واحد.

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

تمرين دالة بايثون 10: تشفير قيصر

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

الحل

def caesar_cipher(input_string, jump):
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    shifted_string = ""
    for char in input_string:
        if char.isalpha():
            shifted_char_idx = (alphabet.index(char.lower()) + jump) % 26
            shifted_char = alphabet[shifted_char_idx]
            if char.isupper():
                shifted_string += shifted_char.upper()
            else:
                shifted_string += shifted_char
        else:
            shifted_string += char
    return shifted_string
 
input_str = "Hello, Python!"
jump = 3
result = caesar_cipher(input_str, jump)
 
print(result)
 
# output:
# Khoor, Sbwkrq!

الشرح

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

تظل أغلب المنطق من الدالة السابقة كما هي. والفرق الوحيد هو في السطر الذي يتم فيه تعريف shifted_char_idx؛ حيث نستبدل jump الثابتة 1 بمتغير jump. وهذا التعديل الوحيد كافٍ لتغيير سلوك الدالة بشكل جذري، مما يؤدي فعليًا إلى إنشاء شفرة قيصر مناسبة!