تعلم البرمجة مع Python


الدرس: برمجة النظام


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

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

التدفقات القياسية (Standard flows)



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

كيف تبدو؟

لقد اعتدت بالتأكيد ، عند استخدام الوظيفة print، على رسالة تظهر على شاشتك. أعتقد أنه من المنطقي بالنسبة لك الآن.

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

ما الفائدة؟ print للعرض على الشاشة أليس كذلك؟

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

هناك ثلاثة تدفقات قياسية:

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

الوصول إلى التدفقات القياسية


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


>>> import sys
>>> sys.stdin # L'entrée standard (standard input)
<_io.TextIOWrapper name='' encoding='cp850'>
>>> sys.stdout # La sortie standard (standard output)
<_io.TextIOWrapper name='' encoding='cp850'>
>>> sys.stderr # L'erreur standard (standard error)
<_io.TextIOWrapper name='' encoding='cp850'>
>>>
 
هل تذكرك هذه العناصر بشيء؟ 

هم من نفس فئة الملفات المفتوحة بفضل الوظيفة open . ولا صدفة وراء ذلك.

في الواقع ، للقراءة أو الكتابة في التدفقات القياسية ، نستخدم الطرق read و write .

وبطبيعة الحال، الإدخال القياسي stdin يمكن قراءة (طريقة read ) وكلا المخرجات stdout و stderr يمكن أن يكتب (طريقة write ) .

لنجرب شيئًا ما:


>>> sys.stdout.write("un test")
un test7
>>>
 
ليست مفاجأة كبيرة ، إلا أنه سيكون من الأفضل مع وجود فاصل سطر في النهاية. هناك ، يتم عرض ما تعيده الطريقة (عدد الأحرف المكتوبة) بعد رسالتنا مباشرة.

>>> sys.stdout.write("Un test\n")
Un test
8
>>>
 

تحرير التدفقات القياسية


يمكنك تعديل sys.stdin ، sys.stdout و sys.stderr . لنجري الاختبار الأول:


>>> fichier = open('sortie.txt', 'w')
>>> sys.stdout = fichier
>>> print("Quelque chose...")
>>>
 
هنا ، لا شيء معروض على الشاشة. من ناحية أخرى ، إذا فتحت الملف sortie.txt، فسترى الرسالة التي مررت إليها print .

لا استطيع ايجاد الملف sortie.txt اين هو؟

يجب أن يكون في دليل بايثون الحالي. لمعرفة موقع هذا الدليل، استخدام وحدة os و وظيفة getcwd ( الحصول على دليل العمل الحالي  ).

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


sys.stdout = sys.__stdout__
 
يمكنك بعد ذلك استدعاء الوظيفة getcwd :

import os
os.getcwd()
 
في هذا الدليل يجب أن تجد ملفك sortie.txt .

إذا كنت قد قمت بتعديل الجداول القياسية، ويبحثون عن الكائنات الأصلية، وتلك لإعادة التوجيه إلى لوحة المفاتيح (للإدخال) والشاشة (للإخراج)، يمكنك العثور عليها في sys.__stdin__، sys.__stdout__و sys.__stderr__.

ومع ذلك ، تنصحنا وثائق Python بالحفاظ على الكائنات الأصلية في متناول اليد بدلاً من البحث عنها sys.__stdin__، sys.__stdout__و sys.__stderr__.

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

الإشارات



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

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

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

الإشارات المختلفة


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

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

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

اعترض signal


ابدأ باستيراد الوحدة signal .


import signal
 
الإشارة التي تهمنا ، كما قلت ، تسمى SIGINT .

>>> signal.SIGINT
2
>>>
 
لاعتراض هذه الإشارة ، سيكون من الضروري إنشاء وظيفة سيتم استدعاؤها إذا تم إرسال الإشارة. تأخذ هذه الوظيفة معلمتين:
  • إشارة (يمكن إرسال إشارات متعددة لنفس الوظيفة) ؛
  • الشخص frame الذي لا يهمنا هنا.
هذه الوظيفة متروكة لك لإنشاءها. بعد ذلك ، يجب أن تكون متصلاً بالإشارة SIGINT .

أولاً ، لنقم بإنشاء وظيفتنا:


import sys

def fermer_programme(signal, frame):
    """ تسمى الوظيفة عندما يحين وقت إغلاق برنامجنا """
    print("حان وقت الإغلاق!")
    sys.exit(0)
 
ما هو السطر الأخير؟

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

للقيام بذلك ، نستخدم وظيفة الوحدة exit (باللغة الإنجليزية)  sys . يأخذ رمز الإرجاع للبرنامج كمعامل.

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

هنا ، يتوقف برنامجنا بشكل طبيعي ، لذا نذهب إلى exit0 .

الآن  دعنا نربط وظيفتنا SIGINT بالإشارة ، وإلا فلن يتم استدعاء وظيفتنا أبدًا.

نحن نستخدم وظيفة لهذا signal . يأخذ كمعلمة:

  • الإشارة التي سيتم اعتراضها ؛
  • الوظيفة المراد توصيلها بهذه الإشارة.

signal.signal(signal.SIGINT, fermer_programme)
 
لا تضع أقواس في نهاية اسم الوظيفة. نرسل المرجع إلى الوظيفة ، ولا ننفذها.

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

للتحقق من أن كل شيء يعمل بشكل جيد ، قم بتشغيل حلقة لا نهائية في برنامجك:


print("Le programme va boucler...")
while True: # الحلقة اللانهائية ، صحيح دائمًا
    continue
 
سأعطيك الكود بالكامل ، إذا كان ذلك يجعل الأمور أكثر وضوحًا:

import signal
import sys

def fermer_programme(signal, frame):
    """ تسمى الوظيفة عندما يحين وقت إغلاق برنامجنا """
    print("حان وقت الإغلاق!")
    sys.exit(0)

# اتصال إشارة لوظيفتنا
signal.signal(signal.SIGINT, fermer_programme)

# برنامجنا...
print("Le programme va boucler...")
while True:
    continue
 
عند تشغيل هذا البرنامج ، سترى رسالة تخبرك أن البرنامج سوف يتكرر ... ويستمر البرنامج في العمل. لا يتوقف. إنه لا يفعل شيئًا ، إنه مجرد حلقات ولكنه سيستمر في التكرار طالما لم يتم مقاطعة تنفيذه.

في نافذة البرنامج ، اكتب CTRL+ Cفي نظام التشغيل Windows أو Linux ، Cmd+ Cفي نظام التشغيل Mac OS X .

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

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

تفسير حجج سطر الأوامر



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

أعتقد أن أولئك الذين يعملون على لينكس لن يجدوا صعوبة في متابعتي. لكنني سأقدم عرضًا تقديميًا صغيرًا لأولئك القادمين من Windows ، حتى يتمكنوا من المتابعة دون صعوبة.

إذا كانت لديك حساسية من وحدة التحكم ، فانتقل إلى الخطوة التالية.

قم بالوصول إلى وحدة تحكم Windows


هناك عدة طرق للوصول إلى وحدة تحكم Windows . الطريقة التي سأستخدمها وسأعرضها عليك تمر عبر قائمة start .

افتح قائمة start وانقر فوق run….  في النافذة التي تفتح ، اكتب cmd ثم اضغط على Enter .

يجب أن ينتهي بك الأمر في نافذة وحدة التحكم ، مما يمنحك العديد من المعلومات الخاصة بالنظام.


C:\WINDOWS\system32\cmd.exe
Microsoft Windows XP [version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
 
ما يهمنا هو السطر الأخير. إنه مسار يخبرك بمكان وجودك في القرص الصلب. من المحتمل أن يكون هذا المسار هو الدليل الرئيسي لحسابك.

C:\Documents and Settings\utilisateur>
 
سنبدأ بالانتقال إلى الدليل الذي يحتوي على مترجم بايثون. مرة أخرى، إذا لم يتغير أي شيء أثناء تثبيت بايثون، ومسار المقابلة هو C:\pythonXY ، XY يمثل أول رقمين من إصدار بايثون. لذلك مع Python 3.4 من المحتمل أن يكون C:\python34 .

استخدم الأمر للانتقال إلى هذا الدليل cd


C:\Documents and Settings\utilisateur>cd C:\python34
C:\Python34>
 
إذا سارت الأمور على ما يرام ، فإن السطر الأخير يخبرك أنك في دليل بايثون.

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

الوصول إلى وسيطات سطر الأوامر


سنستخدم الوحدة مرة أخرى sys . هذه المرة ، سننظر إلى المتغير الخاص به argv .

قم بإنشاء ملف Python جديد. في نظام Windows ، تأكد من حفظه في دليل Python (  C:\python34أسفل Python 3.4 ) .

ضع الكود التالي هناك:


import sys
print(sys.argv)
 
sys.argv يحتوي على قائمة بالوسيطات التي تقوم بتمريرها على سطر الأوامر عند تشغيل البرنامج. لذا حاول استدعاء برنامجك من سطر الأوامر ، ومرره ببعض الحجج.

على نظام Windows :


C:\Python34>python test_console.py
['test_console.py']
C:\Python34>python test_console.py arguments
['test_console.py', 'arguments']
C:\Python34>python test_console.py argument1 argument2 argument3
['test_console.py', 'argument1', 'argument2', 'argument3']
C:\Python34>
 
كما ترى ، فإن العنصر الأول من sys.argv يحتوي على اسم البرنامج ، أيًا كانت تسميته. تحتوي باقي القائمة على حججك (إن وجدت).

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


C:\Python34>python test_console.py "un argument avec des espaces"
['test_console.py', 'un argument avec des espaces']
C:\Python34>
 

تفسير حجج سطر الأوامر


يعد الوصول إلى الحجج أمرًا جيدًا ، لكن تفسيرها يمكن أن يكون مفيدًا أيضًا.

إجراءات بسيطة


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

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


import sys

if len(sys.argv) < 2:
    print("حدد إجراء كمعامل ")
    sys.exit(1)

action = sys.argv[1]

if action == "start":
    print("نبدأ العملية ")
elif action == "stop":
    print("نوقف العملية ")
elif action == "restart":
    print("نعيد العملية ")
elif action == "status":
    print("يتم عرض حالة (بدأ أو توقف؟) للعملية ")
else:
    print("لا أعرف هذا العمل ")
 
من الضروري المرور عبر سطر الأوامر لاختبار هذا البرنامج.

خيارات أكثر تعقيدًا


لكن سطر الأوامر يسمح لك أيضًا بتمرير وسيطات أكثر تعقيدًا مثل الخيارات. في معظم الأحيان ، تكون خياراتنا بالشكل : -option_courte (حرف واحد )  --option_longue ، متبوعًا بحجة أم لا.

في كثير من الأحيان ، يمكن الوصول إلى خيار قصير أيضًا من خيار طويل.

هنا سيتم أخذ المثال الخاص بي من Linux ، لكن ليس عليك أن تكون على نظام Linux لفهمه ، كن مطمئنًا.

Ls يعرض الأمر محتويات الدليل. يمكن تمرير العديد من الخيارات إليه في معلمات تؤثر على ما سيعرضه الأمر في النهاية.

على سبيل المثال ، لعرض جميع الملفات (المخفية أم لا) في الدليل ، نستخدم الخيار المختصر a .


$ ls -a                                                    
. .. file1.txt .file_cache.txt image.png                              
$
 
خيار قصير متاح لخيار طويل all . لذلك تحصل على نفس النتيجة عن طريق كتابة:

$ ls --all                                                 
.  ..  fichier1.txt  .fichier_cache.txt  image.png                              
$
 
للتلخيص ، فإن خياراتنا القصيرة مسبوقة بواصلة واحدة وتتكون من حرف واحد. الخيارات الطويلة مسبوقة بشرطتين وتتكون من عدة أحرف.

تتطلب بعض الخيارات وسيطة ، يتم تحديدها مباشرة بعد الخيار.

على سبيل المثال (لا نزال على Linux ) ، لعرض الأسطر الأولى من الملف ، يمكنك استخدام الأمر head . إذا كنت تريد عرض أول سطور من الملف ، فستستخدم الأمر head -n X .


$ head -n 5 fichier.txt
ligne 1
ligne 2
ligne 3
ligne 4
ligne 5
$
 
في هذه الحالة ، -n يتوقع الخيار وسيطة وهي عدد الصفوف المراد عرضها.

فسر هذه الخيارات باستخدام بايثون


تم الانتهاء من هذا العرض التقديمي الصغير ، فلنعد إلى بايثون.

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


import argparse
parser = argparse.ArgumentParser()
parser.parse_args()
 
  1. أولاً ، نقوم باستيراد الوحدة argparse؛
  2. ثم نقوم بإنشاء  argparse.ArgumentParser يكون مفيدًا في تكوين خياراتنا ليتم تفسيرها ؛
  3. أخيرًا ، نستدعي الطريقة parse_args() في المحلل اللغوي. تقوم هذه الطريقة بإرجاع الحجج المفسرة. سوف نرى كيفية تحديد الخيارات في المحلل اللغوي الخاص بنا ، لجعل الأمور أكثر إثارة للاهتمام. لاحظ أنه ، بشكل افتراضي ، يتم تفسير الوسائط من sys.argv[1:] (أي قائمة الوسائط بدون اسم للبرنامج النصي) .
  4. في الحقيقة ، المحلل اللغوي لدينا ليس فارغًا تمامًا. إذا قمت بتشغيل البرنامج النصي أعلاه باستخدام الخيار –help :
    
    >python code.py --help
    usage: code.py [-h]
    optional arguments:
      -h, --help  show this help message and exit
    >
     
    مما يمنحك لمحة عامة بسيطة عن كيفية استخدام برنامجنا. يتم إنشاء التعليمات (الخيار -h أو --help )افتراضيًا. وإذا لم تستخدم البرنامج النصي بشكل صحيح:
    
    >python code.py --inexistante
    usage: code.py [-h]
    code.py: error: unrecognized arguments: --inexistante
    >
     
    رسائل الخطأ باللغة الإنجليزية ، ولكن يجب أن تكون قادرًا على فهم الخطأ. هنا قمنا ببساطة بتحديد خيار لم يتم تعيينه. دعنا نحاول تحديد واحد:
    
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("x", help="le nombre a mettre au carré")
    parser.parse_args()
     
    أضفنا خيارًا من خلال الطريقة add_argument() . يتطلب الأمر عدة معاملات (الكثير من المعلمات الاختيارية ، في الواقع) ولكننا حددنا اثنين فقط هنا: الخيار ورسالة المساعدة المرتبطة.

    إذا طلبت المساعدة من البرنامج النصي:

    
    >python code.py --help
    usage: code.py [-h] x
    
    positional arguments:
      x           le nombre à mettre au carré
    optional arguments:
      -h, --help  show this help message and exit
    >
     
    يجب علينا الآن تحديد رقم x كمعامل. دعنا نحاول استعادة قيمتها:
    
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("x", help="le nombre a mettre au carré")
    args = parser.parse_args()
    print("Vous avez précisé X =", args.x)
     
    لاسترداد الخيارات (التي نريد القيام بها في معظم الأحيان 

    ) ، نحصل على إرجاع الطريقة parse_args() . تقوم بإرجاع كائن namespace بخياراتنا كسمة.  args.x لذلك ، يؤدي الوصول إلى إرجاع الرقم المحدد من قبل المستخدم:

    
    >python code.py 5
    Vous avez précisé X = 5
    >
     
    في هذا السياق ، نريد رقمًا ... لكن يمكن للمستخدم إدخال أي شيء. هذا ليس شيئًا جيدًا ، فلنعدّل طريقتنا add_argument بحيث يمكن للمستخدم إدخال الأرقام فقط:

    
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("x", type=int, help="le nombre à mettre au carré")
    args = parser.parse_args()
    x = args.x
    retour = x ** 2
    print(retour)
     
    كما ترى ، add_argument يتم تحديد الطريقة هنا باستخدام وسيط جديد: النوع  . نحدد int  ، مما يعني أننا نتوقع رقمًا (سيتم تحويل إدخال المستخدم تلقائيًا).

    يمكنك أيضًا أن ترى أن برنامجنا يقوم الآن بعمل ملموس:

    
    - >python code.py 5
    25
    >python code.py -8
    64
    >python code.py test
    usage: code.py [-h] x
    code.py: error: argument x: invalid int value: 'test'
    >
     
    كما ترى ، فإن التحويل يعمل بشكل جيد ، حتى تظهر رسالة الخطأ إذا لم يقم المستخدم بإدخال رقم.

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

    
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("x", type=int, help=" العدد المطلوب تربيعه ")
    parser.add_argument("-v", "--verbose", action="store_true",
            help=" يزيد الإسهاب ")
    args = parser.parse_args()
    
    x = args.x
    retour = x ** 2
    if args.verbose:
        print("{} ^ 2 = {}".format(x, retour))
    else:
        print(retour)
     
    أضفنا خيارًا جديدًا :  -v  أو -verbose  . نظرًا لأن الاسم يبدأ بواصلة ، يفترض argparse  أن هذا خيار اختياري ، على الرغم من أنه يمكن تغييره.

    لاحظ أننا نسمي الطريقة add_argument مع وسيطة الإجراء . الإجراء المحدد ، "store_true" ، يحول الخيار المحدد إلى قيمة منطقية:

    • إذا تم تحديد الخيار ، args.verbose فسيكون صالحًا True؛
    • إذا لم يتم تحديد الخيار ، args.verbose فسيكون صالحًا False .
    تختلف النتيجة المعروضة بناءً على الخيار ، إذا تم تحديدها ، فستكون رسالة الإرجاع أكثر تفصيلاً:
    
    >python code.py -h
    usage: code.py [-h] [-v] xpositional arguments:
    x le nombre à mettre au carréoptional arguments:
    -h, --help show this help message and exit
    -v, --verbose augmente la verbosité>python code.py 5
    25>python code.py 5 --verbose
    5 ^ 2 = 25>python code.py -v 5
    5 ^ 2 = 25>
     
    ترى أن التعليقات تختلف اعتمادًا على مستوى الإسهاب. لاحظ أيضًا أن رسالة المساعدة تدمج خيارنا الجديد. هذا هو أحد الأسباب (هناك العديد) التي تجعل استخدام argparse  مناسبًا للغاية.

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

قم بتشغيل أمر نظام من Python



هنا سنكون مهتمين بكيفية تشغيل الأوامر من Python . سنرى طريقتين ، ولكن هناك طرق أخرى.

تلك التي سأقدمها لها ميزة التشغيل على Windows .

الوظيفة system


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


os.system("ls") # Linux
os.system("dir") # Windows
 
يمكنك الحصول على رمز الإرجاع الخاص بالطلب ، لكن لا يمكنك التقاط الإرجاع المعروض بالطلب.

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

في الأساس ، إذا قمت بذلك os.system("sleep 5") ، فلن يتوقف البرنامج لمدة خمس ثوان.

الوظيفة popen


تم العثور على هذه الوظيفة أيضًا في الوحدة النمطية os . كما يأخذ الأمر كمعامل.

ومع ذلك ، بدلاً من إرجاع رمز الإرجاع الخاص بالأمر ، فإنه يقوم بإرجاع كائن ، وهو أنبوب (كلمة إنجليزية لـ "pipe" )يسمح لك بقراءة عودة الأمر.

مثال على Linux :


>>> import os
>>> cmd = os.popen("ls")                                                        
>>> cmd                                                                         
                                       
>>> cmd.read()                                                                  
'fichier1.txt\nimage.png\n'                                                     
>>>
 
تؤدي قراءة الأنبوب إلى حظر البرنامج حتى ينتهي الأمر من التنفيذ.

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

باختصار



  • وحدة sys توفر ثلاثة أشياء للوصول إلى تدفق قياسي: stdin ، stdout و stderr .
  • Signal تسمح الوحدة باعتراض الإشارات المرسلة إلى برنامجنا.
  • يتم  استخدام الوحدة argparse لتفسير الحجج التي تم تمريرها في وحدة التحكم لبرنامجنا.
  • أخيرًا ، os تحتوي الوحدة النمطية ، من بين أشياء أخرى ، على العديد من الوظائف لإرسال الأوامر إلى النظام.