تقني Python’s argparse: بناء واجهات سطر الأوامر الأفضل

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

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

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

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

نظرة عامة على واجهات سطر الأوامر في Python

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

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

أهمية تحليل وسائط سطر الأوامر

تحليل وسائط سطر الأوامر ضروري لأسباب عدة: 

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

مقدمة في وحدة argparse وفوائدها

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

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

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

إعداد argparse واستخدامه الأساسي

الآن بعد أن غطينا أهمية تحليل وسيط الأوامر ومزايا استخدام argparse، دعونا نلقي نظرة على كيفية إعداده واستخدامه في سكربت Python.

تثبيت واستيراد argparse

لا حاجة لتثبيت أي شيء بشكل منفصل لأن argparse هو جزء من مكتبة Python القياسية. يمكنك استيراده مباشرة في بداية سكربتك.

import argparse

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

إنشاء محلل وسيطة بسيط

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

parser = argparse.ArgumentParser(description='Process some integers.')

في هذا المثال، نقوم بإنشاء كائن ArgumentParser() ونصف البرنامج. عند اختيار المستخدم لخيار المساعدة (-h أو --help)، سيتم عرض هذا الوصف.

إضافة وسائط موضعية واختيارية

الآن بعد أن قمنا بتطوير المحلل، يمكننا تحديد الوسائط التي سيقبلها برنامجنا.

إضافة وسائط موضعية

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

parser.add_argument('num1', type=int, help='The first number to add.')
parser.add_argument('num2', type=int, help='The second number to add.')

في هذا الكود، num1 و num2 يشيران إلى المعلمات الوضعية.

type=int يشير إلى أنه يجب تحويل المعلمات إلى أعداد صحيحة. المعلمة المساعدة تحدد وصفًا سيظهر في رسالة المساعدة.

إضافة معلمات اختيارية

المعلمات الاختيارية ليست ضرورية عادةً وغالبًا ما توفر خيارات إضافية أو تغيير سلوك البرنامج. عادة ما تبدأ بشرطة واحدة أو شرطتين. سنضيف معلمة اختيارية لتمكين الإخراج المفصل:

parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')

هنا:

• الخيار القصير هو -v (على سبيل المثال، -v). --verbose هو خيار طويل.
• action='store_true' يشير إلى أنه إذا تم اختيار الخيار، سيتم ضبط السمة المفصلة على True؛ وإلا فإنها ستكون False.
• المعلمة help تحدد وصفًا لرسالة المساعدة.

تحليل المعلمات والوصول إلى قيمها

بعد تحديد جميع المعلمات، نحتاج إلى تحليل إدخال سطر الأوامر. استخدم طريقة .parse_args() لتحقيق ذلك.

args = parser.parse_args()

المعلمات المحللة مخزنة الآن في المتغير args كسمات. يمكننا الوصول إليها باستخدام النقطة.

result = args.num1 + args.num2
print('The sum of {} and {} is {}'.format(args.num1, args.num2, result))
if args.verbose:
    print('Verbose mode is enabled.')

وضع كل شيء معًا، ها هو نص كامل يقوم بجمع عددين ويتضمن وضع مفصل اختياري:

import argparse
parser = argparse.ArgumentParser(description='Add two integers.')
parser.add_argument('num1', type=int, help='The first number to add.')
parser.add_argument('num2', type=int, help='The second number to add.')
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
args = parser.parse_args()
result = args.num1 + args.num2
print('The sum of {} and {} is {}'.format(args.num1, args.num2, result))
if args.verbose:
    print('Calculation completed successfully.')

يمكنك تشغيل هذا النص من سطر الأوامر وتقديم المعلمات الوضعية المطلوبة:

python add_numbers.py 3 5
The sum of 3 and 5 is 8

إذا قمت بتضمين الخيار -v أو --verbose، سيقوم النص بطباعة رسالة تفصيلية إضافية:

python add_numbers.py 3 5 --verbose
The sum of 3 and 5 is 8
Calculation completed successfully.

إذا قام المستخدم بتشغيل النص بإضافة الخيار -h أو --help، ستعرض argparse رسالة مساعدة تم إنشاؤها تلقائيًا:

python add_numbers.py -h
usage: add_numbers.py [-h] [-v] num1 num2
Add two integers.
positional arguments:
  num1           The first number to add.
  num2           The second number to add.
optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  Increase output verbosity.

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

معالجة الوسائط العرجاء المتقدمة

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

استخدام nargs لقبول متعدد الوسائط

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

هكذا يمكنك استخدام nargs لقبول أسماء ملفات متعددة:

import argparse
parser = argparse.ArgumentParser(description='Process multiple files.')
parser.add_argument('filenames', nargs='+', help='List of files to process.')
args = parser.parse_args()
for filename in args.filenames:
    print(f'Processing file: {filename}')
    # أضف كود معالجة الملفات هنا

في هذه الحالة، يقوم nargs='+' بتعليم المحلل لتوقع واحد أو أكثر من الوسائط في أسماء الملفات. يمكن للمستخدم تقديم العديد من أسماء الملفات حسب الحاجة، وسيتم حفظها في قائمة تسمى args.filenames.

إذا كنت ترغب في قبول عدد معين من الوسائط، قم بتعيين nargs بهذا الرقم. على سبيل المثال، nargs=2 يتطلب بالضبط وسيطين.

تنفيذ خيارات لتقييد قيم الوسيط

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

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

import argparse
parser = argparse.ArgumentParser(description='Perform actions in different modes.')
parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.')
args = parser.parse_args()
if args.mode == 'backup':
    print('Backing up data...')
    # الكود للنسخ الاحتياطي هنا
elif args.mode == 'restore':
    print('Restoring data...')
    # الكود للاستعادة هنا
elif args.mode == 'delete':
    print('Deleting data...')
    # الكود للحذف هنا

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

التعامل مع العلامات البولية والتبديلات

العلامات البولية هي خيارات تمكّن أو تعطّل وظائف محددة في تطبيقك. عادةً ما يتم تحديدها بدون قيمة، فقط من خلال تضمين العلامة في الأمر. يمكنك التعامل مع هذه العلامات في argparse باستخدام معلمة action.

على سبيل المثال، دعنا نضيف وضع تصحيح في نص:

import argparse
parser = argparse.ArgumentParser(description='A script with debug mode.')
parser.add_argument('--debug', action='store_true', help='Enable debug output.')
args = parser.parse_args()
if args.debug:
    print('Debug mode is enabled.')
    # معلومات تصحيح إضافية هنا
else:
    print('Debug mode is disabled.')

من خلال استخدام action='store_true'، ستقوم العلامة --debug بتعيين args.debug إلى True عند الوجود وFalse خلاف ذلك.

تعيين قيم افتراضية ووسيطات مطلوبة

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

إليك مثال:

import argparse
parser = argparse.ArgumentParser(description='Adjust program settings.')
parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.')
args = parser.parse_args()
print(f'Timeout is set to {args.timeout} seconds.')

في هذ scenar، إذا لم يحدد المستخدم --timeout، فإن الافتراضي هو 30 ثانية.

لجعل معطى اختياري إلزاميًا، set required=True.

import argparse
parser = argparse.ArgumentParser(description='Send a message.')
parser.add_argument('--recipient', required=True, help='Recipient of the message.')
args = parser.parse_args()
print(f'Sending message to {args.recipient}.')

سيتطلب النص الآن معطى --recipient.

تخصيص رسائل المساعدة والأخطاء

توفير رسائل واضحة ومفيدة للمستخدمين هو جزء أساسي من تطوير برنامج سطر الأوامر الفعّال. تقوم وحدة Python’s argparse تلقائيًا بإنشاء رسائل المساعدة، ولكن يمكنك تعديل هذه الرسائل لتناسب احتياجاتك بشكل أفضل.

إنشاء رسائل مساعدة تلقائية

بشكل افتراضي، تنشئ argparse رسالة مساعدة يمكن الوصول إليها باستخدام الخيارات -h أو --help. تتضمن هذه الرسالة استخدام البرنامج، ووصفًا، ومعلومات حول كل معطى.

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

import argparse
parser = argparse.ArgumentParser(description='Calculate factorial of a number.')
parser.add_argument('number', type=int, help='The number to calculate the factorial for.')
args = parser.parse_args()

عندما يقوم المستخدم بتشغيل النص بـ -h، سيرى:

usage: script.py [-h] number
Calculate factorial of a number.
positional arguments:
  number      The number to calculate the factorial for.
optional arguments:
  -h, --help  show this help message and exit

توفر هذه الرسالة المساعدة التلقائية معلومات مفيدة دون الحاجة إلى أي جهد إضافي.

تخصيص وصف المساعدة ورسائل الاستخدام

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

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

import argparse
parser = argparse.ArgumentParser(
    description='Convert temperatures between Celsius and Fahrenheit.',
    epilog='Enjoy using the temperature converter!',
    usage='%(prog)s [options] temperature')
parser.add_argument('temperature', type=float, help='Temperature value to convert.')
parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.')
parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.')
args = parser.parse_args()

الآن، عندما يفحص المستخدم رسالة المساعدة، ستتضمن الوصف المخصص وطريقة الاستخدام، والختام:

python file.py --help

usage: p.py [options] temperature

Convert temperatures between Celsius and Fahrenheit.

positional arguments:
  temperature      Temperature value to convert.

options:
  -h, --help       show this help message and exit
  --to-fahrenheit  Convert Celsius to Fahrenheit.
  --to-celsius     Convert Fahrenheit to Celsius.

–to-fahrenheit تحويل الدرجات الحرارية من مئوية إلى فهرنهايت.

–to-celsius تحويل الدرجات الحرارية من فهرنهايت إلى مئوية.

إدارة معالجة الأخطاء وردود فعل المستخدم

import argparse
import sys
class CustomArgumentParser(argparse.ArgumentParser):
    def error(self, message):
        print(f'Error: {message}')
        self.print_help()
        sys.exit(2)
parser = CustomArgumentParser(description='Divide two numbers.')
parser.add_argument('numerator', type=float, help='The numerator.')
parser.add_argument('denominator', type=float, help='The denominator.')
args = parser.parse_args()
if args.denominator == 0:
    parser.error('Denominator cannot be zero.')
result = args.numerator / args.denominator
print(f'Result: {result}')

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

Python file.py 6 0
Error: Denominator cannot be zero.
usage: file.py [-h] numerator denominator
Divide two numbers.
positional arguments:
  numerator    The numerator.
  denominator  The denominator.
options:
  -h, --help   show this help message and exit

إحدى الطرق هي تجاوز طريقة الخطأ في فئة فرعية من ArgumentParser:

import argparse
import os
parser = argparse.ArgumentParser(description='Read a file and display its contents.')
parser.add_argument('filepath', help='Path to the file.')
args = parser.parse_args()
if not os.path.exists(args.filepath):
    parser.error(f"The file {args.filepath} does not exist.")
with open(args.filepath, 'r') as file:
    contents = file.read()
    print(contents)

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

python app..py file
usage: p.py [-h] filepath
app.py: error: The file file does not exist.

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

تشغيل النص بمسار غير صحيح سيعرض الخطأ أدناه:

أمثلة وحالات استخدام من العالم الحقيقي

فهم كيفية استخدام وحدة argparse في ظروف العالم الحقيقي سيجعل وظائفها أكثر وضوحًا. دعنا نلقي نظرة على بعض حالات استخدام argparse في تطبيقات العالم الحقيقي.

إنشاء آلة حاسبة سطر الأوامر

import argparse
parser = argparse.ArgumentParser(description='Simple command-line calculator.')
parser.add_argument('num1', type=float, help='First number.')
parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.')
parser.add_argument('num2', type=float, help='Second number.')
args = parser.parse_args()
if args.operator == '+':
    result = args.num1 + args.num2
elif args.operator == '-':
    result = args.num1 - args.num2
elif args.operator == '*':
    result = args.num1 * args.num2
elif args.operator == '/':
    if args.num2 == 0:
        print('Error: Division by zero is not allowed.')
        exit(1)
    result = args.num1 / args.num2
print(f'The result is: {result}')

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

python calculator.py 10 + 5
The result is: 15.0

إليك كيفية التعامل مع هذه المهمة:

في هذا النص، تم استخدام وحدة argparse لتحديد ثلاثة arguments موضوعية: رقمين وعامل. يحدد argument choices العامل لرموز الحساب الصحيحة. عندما يشغل المستخدم النص، يمكنه إجراء هذه الحسابات:

تظهر هذه الحاسبة الأساسية كيف يمكن لخيارات سطر الأوامر تعزيز مرونة البرنامج وتفاعله.

إنشاء نص نصي لمعالجة الملفات بخيارات متعددة

import argparse
parser = argparse.ArgumentParser(description='Process text files.')
parser.add_argument('input_file', help='Path to the input file.')
parser.add_argument('-o', '--output', help='Path to the output file.')
parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.')
parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.')
args = parser.parse_args()
لنفترض أنك بحاجة إلى نص يعالج ملفات نصية ويوفر خيارات مثل تعيين ملف إخراج، اختيار وضع معالجة، وتمكين الإخراج التفصيلي.
with open(args.input_file, 'r') as file:
    content = file.read()
if args.verbose:
    print(f'Reading from {args.input_file}')
إليك مثال على كيفية إعداده:
if args.mode == 'uppercase':
    processed_content = content.upper()
else:
    processed_content = content.lower()
if args.verbose:
    print('Processing content')
# قراءة الملف الداخلي
if args.output:
    with open(args.output, 'w') as file:
        file.write(processed_content)
    if args.verbose:
        print(f'Writing output to {args.output}')
else:
    print(processed_content)

# معالجة المحتوى

python text_processor.py input.txt -o output.txt --mode lowercase -v
Reading from input.txt
Processing content
Writing output to output.txt

# كتابة إلى الملف الخارجي أو طباعته على الشاشة

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

تطوير أداة سطر الأوامر مع أوامر فرعية

import argparse
parser = argparse.ArgumentParser(description='Manage tasks.')
subparsers = parser.add_subparsers(dest='command', required=True)
في تطبيقات أكثر تعقيدًا، قد تكون هناك حاجة إلى أوامر فرعية، على غرار كيفية عمل git باستخدام أوامر مثل git commit وgit push. يوفر وحدة argparse مُحللات فرعية لهذا الغرض.
parser_add = subparsers.add_parser('add', help='Add a new task.')
parser_add.add_argument('name', help='Name of the task.')
parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.')
ها هي الطريقة لصنع أداة سطر أوامر مع أوامر فرعية:
parser_list = subparsers.add_parser('list', help='List all tasks.')
parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.')
# الأمر الفرعي 'add'
parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.')
parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.')
args = parser.parse_args()
if args.command == 'add':
    print(f"Adding task '{args.name}' with priority {args.priority}")
    # الأمر الفرعي 'list'
elif args.command == 'list':
    print('Listing tasks')
    if args.all:
        print('Including completed tasks')
    # الأمر الفرعي 'complete'
elif args.command == 'complete':
    print(f'Marking task {args.task_id} as completed')
    # كود لإضافة المهمة

# كود لعرض المهام

# كود لإكمال المهمة

python task_manager.py add "Write report" -p 2
Adding task 'Write report' with priority 2

في هذا المثال، يحتوي السكريبت على ثلاثة أوامر فرعية: add، list، و complete. لكل أمر فرعي وسجلاته. عند تشغيل المستخدمين للسكريبت، يدخلون الأمر الفرعي وأي معلمات أخرى.

python task_manager.py list
Listing tasks

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

python task_manager.py complete 3
Marking task 3 as completed

عرض المهام

وضع علامة على المهام كمكتملة:

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

أفضل الممارسات والنصائح لـ Python argparse

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

إليك بعض الممارسات المثلى عند العمل مع وحدة argparse.

تنظيم الشفرة لتحسين القراءة والصيانة

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

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

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

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

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

اختبار وتصحيح تطبيقات سطر الأوامر

إن اختبار تطبيقاتك أمر حاسم لضمان عملها بشكل صحيح واكتشاف الأخطاء في وقت مبكر. كتابة اختبارات الوحدة باستخدام إطارات اختبار Python مثل unittest أو pytest هو نهج ممتاز لاختبار الشيفرة الخاصة بك. تسمح لك هذه الاختبارات بتقليد مدخلات مختلفة والتأكد من أن وظائفك تعمل بشكل صحيح.

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

من الضروري أيضًا التعامل بلياقة مع الاستثناءات. باستخدام كتل try-except، يمكنك التقاط الأخطاء وتقديم رسائل مفيدة للمستخدم. يجعل ذلك تطبيقك أكثر استقرارًا وسهولة للاستخدام.

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

مقارنة argparse مع مكتبات تحليل الوسائط الأخرى

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

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

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

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

الاستنتاج

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