كيفية قراءة إدخال المستخدم من لوحة المفاتيح في بايثون

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

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

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

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

كيفية قراءة مدخلات لوحة المفاتيح في بايثون باستخدام input()

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

إن البدء أمر بسيط للغاية. ما عليك سوى تشغيل shell مفسّر بايثون، ويمكنك على الفور استخدام input() للتفاعل الأساسي.

لتجربته، افتح الطرفية أولاً وقم بتشغيل بايثون REPL عن طريق كتابة python والضغط على Enter. سيؤدي هذا إلى عرض موجه بايثون المألوف الذي يشير إلى أن REPL جاهز. استخدم input()، مع تمرير أي سلسلة بين قوسين:

>>> input("What is your name? ")
What is your name? pyarabic
'pyarabic'

بمجرد تنفيذ التعليمات البرمجية، سيتم عرض السلسلة التي حددتها في input() على الشاشة، وستتمكن من كتابة أي استجابة. كما سيتم طباعة استجابتك على الشاشة بمجرد الضغط على Enter. وذلك لأن REPL تطبع قيم الإرجاع تلقائيًا – في هذه الحالة، القيمة التي تم إرجاعها بواسطة input().

أفضل ممارسة عند استخدام input() هي تعيينها إلى متغير يمكنك استخدامه لاحقًا في الكود. على سبيل المثال، يمكنك أن تطلب من المستخدم كتابة اسمه. قم بتعيين input() إلى متغير name:

>>> name = input("What is your name? ")
What is your name? pyarabic

يؤدي هذا إلى طباعة المطالبة “?What is your name” وإيقافها مؤقتًا، في انتظار إدخال لوحة المفاتيح. بعد أن يكتب المستخدم اسمًا ويضغط على Enter، يتم تخزين سلسلة النص في متغير name. هذه المرة، لن تتم طباعة إدخالك تلقائيًا في REPL، لأن المتغير يخزن القيمة بدلاً من ذلك.

يمكنك الآن استخدام المتغير في أي جزء من الكود في نفس الجلسة، مثل طباعة تحية مخصصة:

>>> print(f"Hello there, {name}!")
Hello there, pyarabic!

استجاب برنامجك بناءً على الاسم المخصص الذي قدمته. لقد استخدم الاسم الذي قدمته في طلب الإدخالinput().

هذا هو النمط الأساسي عند العمل مع إدخال لوحة مفاتيح بايثون:

1. استدعاء input() مع مطالبة تشرح ما يجب إدخاله.
2. تعيين النتيجة إلى متغير باسم وصفي.
3. استخدم هذا المتغير لاحقًا في الكود الخاص بك.

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

ملاحظة: باستخدام input() تتم معالجة جميع المدخلات كأحرف سلسلة، ولا يتم تنفيذ مدخلات المستخدم ككود. ومع ذلك، يجب أن تكون حذرًا من مدخلات المستخدم وتقييمها قبل تنفيذها في برنامجك، أو استخدامها في استعلامات قاعدة البيانات، أو الوثوق بها بأي شكل آخر.

هذه مجرد الخطوة الأولى التي يمكنك اتخاذها لاستخدام input() في برنامجك التفاعلي. هناك تعديلات أخرى يمكنك إجراؤها لضمان أن الدالة تأخذ كافة أنواع البيانات.

قراءة أنواع بيانات محددة باستخدام دالة الإدخال

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

نظرًا لأن input() تعيد سلاسل، فأنت بحاجة إلى تحويل كل المدخلات إلى نوع البيانات المطلوب قبل استخدامها في الكود. إذا طلبت إدخالًا رقميًا، فستظل النتيجة تُعاد كسلسلة:

>>> age = input("How old are you? ")
How old are you? 35

>>> type(age)
<class 'str'>

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

لحسن الحظ، يجعل بايثون تحويل سلاسل input إلى أي نوع بيانات مطلوب أمرًا سهلاً. يمكنك تمرير نتيجة input() إلى دالة تحويل النوع مثل int() أو float() أو bool() لتحويلها عند الطلب. على سبيل المثال، سيؤدي استخدام تحويل النوع int() إلى تحويل input إلى نوع العدد الصحيح المطلوب:

>>> age = int(input("How old are you? "))
How old are you? 35

>>> type(age)
<class 'int'>

لقد قمت بتغليف input() في دالة تحويل النوع، int(). تقوم هذه الدالة بتحويل أي سلسلة رقمية إلى عدد صحيح. الآن عندما تتحقق من نوع متغير العمر، فإنها تعيد int.

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

>>> weight = float(input("What is your weight in pounds? "))
What is your weight in pounds? 165

>>> weight
165.0

>>> type(weight)
<class 'float'>

في المثال، تقوم بتحويل “165” إلى قيمة الفاصلة العائمة 165.0. تقوم بفحص نوع الوزن للتأكد من أن التحويل تم بالشكل المتوقع.

ستستخدم int() أو float() كلما احتجت إلى قيمة عددية. سيبدأ الإدخال دائمًا كسلسلة، ولكن يمكنك تحويله إلى أرقام حسب الحاجة. هذه نقطة مهمة يجب ملاحظتها لضمان الحصول على النتائج المرجوة من برنامجك التفاعلي.

معالجة الأخطاء باستخدام input() في بايثون

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

>>> age = int(input("How old are you? "))
How old are you? Thirty-five
Traceback (most recent call last):
  ...
ValueError: invalid literal for int() with base 10: 'Thirty-five'

يثير هذا الكود خطأ ValueError نظرًا لأن بايثون لا يمكنه تحويل “Thirty-five” إلى عدد صحيح. قد لا يفهم المستخدمون هذا الخطأ.

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

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

while True:
    try:
        age = int(input("How old are you? "))
    except ValueError:
        print("Please enter a number for your age.")
    else:
        break

print(f"Next year, you'll be {age + 1} years old")

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

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

PS> python integer_input.py
How old are you? Thirty-five
Please enter a number for your age.
How old are you? 35
Next year, you'll be 36 years old

سيتم تحميل محتوى الملف الخاص بك، وسيسألك “كم عمرك؟”. الآن إذا أدخلت سلسلة مثل “Thirty-five”، فسيتعامل برنامجك مع الخطأ بسلاسة ويعطيك معلومات حول سبب عدم نجاح إدخالك. سيمنحك فرصة أخرى لإدخال القيم الصحيحة، وسينفذ البرنامج حتى النهاية.

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

قراءة إدخالات متعددة من إدخال المستخدم

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

في بايثون، يسمح لك نوع البيانات list بتخزين وتنظيم تسلسل من العناصر. القوائم جيدة لتخزين إدخالات متعددة من المستخدمين. يمكنك أن تطلب من المستخدمين إدخال إدخالات متعددة، والتي يمكن لبرنامجك تخزينها في قائمة. افتح المجلد الخاص بك وقم بإنشاء ملف بايثون جديد، list_input.py. أدخل الكود التالي:

user_colors = input("Enter the three secondary colors separated by commas: ")
colors = [s.strip() for s in user_colors.split(",")]

print(f"List of colors: {colors}")

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

في الطرفية، قم بتشغيل ملف بايثون لرؤية الكود أثناء العمل:

PS> python list_input.py
Enter the three secondary colors separated by commas: orange, purple, green
List of colors: ['orange', 'purple', 'green']

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

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

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

print("Name at least 3 colors in the Kenyan flag.")

kenya_flag_colors = {"green", "black", "red", "white"}
user_colors = set()

while len(user_colors) < 3:
    color = input("Enter a color on the Kenyan flag: ")
    user_colors.add(color.lower())

if user_colors.issubset(kenya_flag_colors):
    print(
        "Correct! These colors are all in the Kenyan flag: "
        + ", ".join(user_colors)
    )
else:
    print(
        "Incorrect. The colors of the Kenyan flag are: "
        + ", ".join(kenya_flag_colors)
    )

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

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

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

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

الآن يمكنك تشغيل ملف multiple_inputs.py في الطرفية لرؤية الكود أثناء العمل:

PS> python multiple_inputs.py
Name at least 3 colors in the Kenyan flag.
Enter a color on the Kenyan flag: Red
Enter a color on the Kenyan flag: Yellow
Enter a color on the Kenyan flag: Green
Incorrect. The colors of the Kenyan flag are: green, red, black, white

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

إليك مثال آخر لكيفية جمع مدخلات المستخدم دون مطالبة المستخدم بشكل متكرر، مثل المثال الأخير. إنه قابل للتطوير حيث يمكنك إضافة المزيد من الأسئلة متعددة الإجابات إلى البرنامج. أنشئ ملف بايثون آخر وأطلق عليه اسم quiz.py. داخل الملف، أدخل الكود التالي:

questions = {
    "What are the four colors of the Kenyan flag? ": {
        "green", "black", "red", "white"
    },
    "What are the three colors of the French flag? ": {
        "blue", "red", "white"
    },
    "How do you spell the first three numbers in Norwegian? ": {
        "en", "to", "tre"
    },
}

for question, correct in questions.items():
    while True:
        answers = {
            answer.strip().lower() for answer in input(question).split(",")
        }
        if len(answers) == len(correct):
            break
        print(f"Please enter {len(correct)} answers separated by comma")
    if answers == correct:
        print("Correct")
    else:
        print(f"No, the correct answer is {', '.join(correct)}")

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

يتنقل الكود عبر عناصر القاموس باستخدام .items(). داخل الحلقة، يدخل حلقة while True لحث المستخدم بشكل متكرر على إدخال العدد الصحيح من الإجابات.

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

ثم يمكنك مقارنة مجموعة إجابات المستخدم بالمجموعة الصحيحة باستخدام ==. إذا تطابقت الإجابات، يمكنك طباعة رسالة “صحيحة”. وإلا، تظهر رسالة توضح الإجابات الصحيحة. يمكنك الآن تشغيل الملف في الطرفية لمشاهدة كود الاختبار قيد التشغيل:

PS> python quiz.py
What are the four colors of the Kenyan flag? red, white, black
Please enter 4 answers separated by comma
What are the four colors of the Kenyan flag? red, white, black, green
Correct
What are the three colors of the French flag? blue, red, green
No, the correct answer is red, blue, white
How do you spell the first three numbers in Norwegian? en, to, tre
Correct

تأمين مدخلات المستخدم الحساسة

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

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

ملاحظة: عند العمل بكلمات المرور والمعلومات الحساسة الأخرى مثل مفاتيح API، يجب عليك التأكد من عدم إرسالها إلى GitHub أو تسريبها بأي شكل آخر. إن استخدام getpass يحمي فقط من إدخال المعلومات الحساسة. لا يزال يتعين عليك تخزين المعلومات بأمان.

قم بإنشاء ملف بايثون وأطلق عليه اسم sensitive.py. داخل هذا الملف، اكتب الكود التالي:

import os
import getpass

def verify_email(email):
    allowed_emails = [
        email.strip() for email in os.getenv("ALLOWED_EMAILS").split(",")
    ]
    return email in allowed_emails

def main():
    email = getpass.getpass("Enter your email address: ")
    if verify_email(email):
        print("Email is valid. You can proceed.")
    else:
        print("Incorrect email. Access denied.")

if __name__ == "__main__":
    main()

يقوم هذا البرنامج النصي باستيراد getpass واستخدامه لإخفاء إدخال عنوان البريد الإلكتروني. لديك أيضًا متغير بيئة يتم تخزينه خارج البرنامج النصي. يمكنك استخدام متغير البيئة لتجنب إضافة معلومات حساسة مباشرة إلى الكود. يمكنك الوصول إلى متغيرات البيئة باستخدام getenv() في وحدة os.

تستخدم عبارة “name-main” للتحقق مما إذا كان يتم تشغيل البرنامج النصي الخاص بـبايثون أو استيراده. إذا كان البرنامج النصي الرئيسي هو الذي يتم تنفيذه، فإنه يستدعي main().

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

PS> set ALLOWED_EMAILS=info@example.com

هذه طريقة أساسية لضمان عدم ظهور معلومات حساسة في البرنامج الرئيسي. إحدى الطرق التي يمكنك من خلالها تنظيم متغيرات البيئة المتعلقة بمشروع ما هي تخزينها في ملف .env. يجب التأكد من عدم تحميل هذا الملف مطلقًا إلى مساحات عامة مثل GitHub أو السحابة.

الآن قم بتشغيل الملف sensitive.py وأدخل البريد الإلكتروني الذي قمت بتعيينه في متغير البيئة:

PS> python sensitive.py
Enter your email:
Email is correct. You can proceed.

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

أتمتة تقييم إدخال المستخدم باستخدام PyInputPlus

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

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

وحدة PyInputPlus عبارة عن حزمة بايثون تعتمد على input() وتعززها للتحقق من صحة إدخال المستخدم وإعادة مطالبته به. تم إنشاؤها في عام 2019 بواسطة Al Sweigart، مؤلف Automate the Boring Stuff with Python، وتهدف إلى تقليل كود التحقق من صحة الإدخال الممل من خلال توفير مجموعة من أنواع الإدخال وخيارات التحقق.

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

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

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

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

PS> python -m venv venv

لقد قمت بإنشاء مجلد باسم venv. قم بتنشيط هذه البيئة الافتراضية باستخدام الأمر التالي:

PS> venv\Scripts\activate
(venv) PS>

بمجرد تنشيط البيئة الافتراضية الخاصة بك، يمكنك تثبيت PyInputPlus. ستستخدم pip لتثبيت الحزمة في البيئة. في الطرفية، أدخل هذا الأمر:

(venv) PS> python -m pip install pyinputplus

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

قم بإنشاء ملف بايثون وأطلق عليه اسم inputplus.py. في الملف، أدخل الكود التالي الذي سيساعدك في إجراء التجارب باستخدام PyInputPlus:

import pyinputplus as pyip

age = pyip.inputInt(prompt="Enter your age: ", min=0, max=120)
print(f"Your age is: {age}")

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

PS> python inputplus.py
Enter your age: -1
Number must be at minimum 0.
Enter your age: 125
Number must be at maximum 120.
Enter your age: 35
Your age is: 35

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

مع PyInputPlus، يمكنك تقليل تعقيد استخدام input() في شكله الأساسي. كما أن الكود مختصر وموجز، مما يضمن لك إمكانية إنشاء برامج تفاعلية معقدة.

في المثال التالي، ستقوم بإنشاء تطبيق مصرفي سيتم تشغيله في الطرفية. سيوضح المثال مقدار ما يمكنك فعله بالمكتبة لتحسين input().

الآن، في نفس المجلد، قم بإنشاء ملف بايثون آخر. يمكنك تسميته banking_app.py. داخل الملف، يمكنك كتابة الكود التالي:

import pyinputplus as pyip

account_balance = 1000

print("Welcome to REALBank.")
while True:
    print(f"\nYour account balance: ${account_balance}")
    transaction_type = pyip.inputChoice(["Deposit", "Withdraw", "Exit"])

    if transaction_type == "Exit":
        break
    elif transaction_type == "Deposit":
        deposit_amount = pyip.inputInt(
            prompt="Enter amount (max $10,000): $", min=0, max=10000
        )
        account_balance += deposit_amount
        print(f"Deposited ${deposit_amount}.")
    elif transaction_type == "Withdraw":
        withdrawal_amount = pyip.inputInt(
            prompt="Enter amount: $", min=0, max=account_balance
        )
        account_balance -= withdrawal_amount
        print(f"Withdrew ${withdrawal_amount}.")

print("\nThank you for choosing REALBank. We hope to see you again soon!")

بمجرد حفظ الملف، يمكنك تشغيله. سيبدأ تطبيق الخدمات المصرفية الافتراضية ، ويطالبك بإدخال خيارات مختلفة.

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

يُطلب من المستخدم اختيار أحد الخيارات باستخدام pyip.inputChoice(). إذا اختار المستخدم الخروج، تنتهي الحلقة، ويطبع البرنامج رسالة وداع. يمكن أن تسمح هذه التفاعلية للمستخدم بإجراء معاملات متعددة:

PS> python banking_app.py
Welcome to REALBank.

Your account balance: $1000
Please select one of: Deposit, Withdraw, Exit
Deposit
Enter amount (max $10,000): $5000
Deposited $5000.

Your account balance: $6000
Please select one of: Deposit, Withdraw, Exit

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

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

Your account balance: $6000
Please select one of: Deposit, Withdraw, Exit
Withdraw
Enter amount: $4000
Withdrew $4000.

Your account balance: $2000
Please select one of: Deposit, Withdraw, Exit

ماذا لو قرر المستخدم سحب مبلغ أكبر من رصيده البنكي؟ سيتمكن برنامجك من التعامل مع هذه المشكلة بسهولة، من خلال رسالة مفهومة:

Your account balance: $2000
Please select one of: Deposit, Withdraw, Exit
Withdraw
Enter amount: $4000
Number must be at maximum 2000.
Enter amount: $2000
Withdrew $2000.

Your account balance: $0
Please select one of: Deposit, Withdraw, Exit

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

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

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

بعد ذلك، قمت بالتدرب على استراتيجيات التعامل مع الأخطاء، والتأكد من أن برامجك تتعامل بسلاسة مع المدخلات غير المتوقعة، وتحسين تجربة المستخدم ومتانة البرنامج. ثم استخدمت وحدة getpass، التي تقدم طريقة آمنة لقبول المعلومات الحساسة مثل كلمات المرور دون عرضها على الشاشة.

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

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

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