التعليقات هي عبارات دخيلة على الشيفرات البرمجية وليست جزءًا منها، إذ تتجاهلها المصرّفات (compilers) والمترجمات (interpreters). يُسهِّل تضمين التعليقات في الشيفرات من قراءتها وفهمها ومعرفة وظيفة كل جزء من أجزائها، لأنها توفر معلومات وشروحات حول ما يفعله كل جزء من البرنامج.

بناءً على الغرض من البرنامج، يمكن أن تكون التعليقات بمثابة مُذكَّرات لك، أو يمكنك كتابتها لمساعدة المبرمجين الآخرين على فهم الشيفرة.

يُستحسَن كتابة التعليقات أثناء كتابة البرامج أو تحديثها، لأنّك قد تنسى السياق وتسلسل الأفكار لاحقًا، والتعليقات المكتوبة في وقت لاحق قد تكون أقل فائدة على المدى الطويل.

صياغة التعليقات

تبدأ التعليقات السطرية في بايثون بالعلامة # ومسافة بيضاء، وتستمر حتى نهاية السطر.

بشكل عام، ستبدو التعليقات على النحو التالي:

# هذا تعليق

نظرًا لأنَّ التعليقات لا تُنفَّذ، فعند تشغيل البرنامج، لن ترى أي إشارة للتعليقات، فالتعليقات توضع في الشيفرة المصدرية ليقرأها الناس، وليس للتنفيذ.

في برنامج "Hello, World!‎" قد يبدو التعليق كما يلي:

# في سطر الأوامر “Hello, World!” طبع
print("Hello, World!")

في الحلقة for، قد تبدو التعليقات كما يلي:

# كمصفوفة من السلاسل النصية sharks تعريف المتغير
sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

# sharks تمر على المصفوفة For حلقة 
for shark in sharks:
   print(shark)

يجب أن تُحاذى التعليقات على نفس المسافة البادئة (indent) للشيفرة التي تعلّق عليها. بمعنى أنّ التعليقات على دالة ليس لها مسافة بادئة ستكون هي أيضًا بدون مسافة بادئة، وسيكون لكل مستوى من المسافات البادئة التالية تعليقات تتوافق مع الشيفرات البرمجية التي تعلِّق عليها.

على سبيل المثال، الشيفرة التالية تعرّف الدالة again()‎ التي تسأل المستخدم إن كان يريد استخدام الحاسبة مجدَّدًا، مع بعض التعليقات:

...
# لسؤال المستخدم إن كان يريد استخدام الحاسبة مجددا again() تعريف الدالة

def again():

    # أخذ المدخلات من المستخدم
    calc_again = input('''
Do you want to calculate again?
Please type Y for YES or N for NO.
''')

    # calculate() فستُنفّذ الدالة Y إن أدخل المستخدم 

    if calc_again == 'Y':
        calculate()

    # فقل وداعا للمستخدم وأنه البرنامج N إن كتب المستخدم

    elif calc_again == 'N':
        print('See you later.')

    # إن أدخل المستخدم حرفًا آخر، فأعد تنفيذ الدالة
    else:
        again()

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

يجب أن تجيب التعليقات عن سؤال "لماذا" بدلًا من "ماذا" أو "كيف". لأنه ما لم تكن الشيفرة صعبة ومعقَّدة، فإن النّظر إلى الشيفرة عمومًا كافٍ لفهم ما الذي تفعله الشيفرة، أو كيف تفعله.

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

التعليقات الكتلية

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

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

فيما يلي مثال على كتلة تعليقات تشرح ما يحدث في الدالة main()‎ المعرفة أدناه:

# parser الوسائط عبر المتغير main  سوف تحلل الدالة
# الوسائط ستُحدَّد بواسطة المستخدم على سطر الأوامر. هذا سيمرر
# الذي يريد المستخدم تحليله مع اسم الملف word الوسيط
# المراد استخدامه، وكذلك تقديم نص مساعد إذا لم يُدخل المستخدم 
# الوسيط بشكل صحيح
def main():
  parser = argparse.ArgumentParser()
  parser.add_argument(
      "word",
      help="the word to be searched for in the text file."
  )
  parser.add_argument(
      "filename",
      help="the path to the text file to be searched through"
  )
...

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

التعليقات السطرية

توضع التعليقات السطرية (Inline comments) على نفس السطر الذي توجد فيه العبارة البرمجية. ومثل التعليقات الأخرى، فإنها تبدأ بالعلامة # ومسافة بيضاء واحدة.

بشكل عام، تبدو التعليقات السطرية كما يلي:

[code]  # تعليق مضمن حول الشيفرة

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

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

z = 2.5 + 3j  # إنشاء عدد عقدي

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

x = 8  # بقيمة عشوائية x ابتداء

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

تعليق جزء من الشيفرة بدواعي الاختبار والتنقيح

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

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

import random

number = random.randint(1, 25)

# number_of_guesses = 0

for i in range(5):
# while number_of_guesses < 5:
    print('Guess a number between 1 and 25:')
    guess = input()
    guess = int(guess)

    # number_of_guesses = number_of_guesses + 1

    if guess < number:
        print('Your guess is too low')

    if guess > number:
        print('Your guess is too high')

    if guess == number:
        break

if guess == number:
    print('You guessed the number!')

else:
    print('You did not guess the number. The number was ' + str(number))

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

خلاصة

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

يمكنك تعلم المزيد عن التعليقات من موسوعة حسوب.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Write Comments in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

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

يوفر سطر أوامر بايثون التفاعلي (Python interactive console)، ويسمى أيضًا مترجم بايثون (Python interpreter) للمبرمجين طريقة سريعة لتنفيذ الأوامر، وتجربة أو اختبار التعليمات البرمجية دون الحاجة إلى إنشاء وكتابة أي شيفرة برمجية.

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

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

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

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

python

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

cd environments
. my_env/bin/activate

ثم اكتب الأمر python:

(my_env) sammy@ubuntu:~/environments$ python

في مثالنا الحالي، الإصدار الافتراضي هو Python 3.5.2، والذي يُعرَض في المخرجات بمجرد إدخال الأمر، إلى جانب إشعار حقوق الملكية، وبعض الأوامر التي يمكنك كتابتها للحصول على معلومات إضافية:

Python 3.5.2 (default, Nov 17 2016, 17:05:23) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

في بداية كل سطر ستجد ثلاث علامات "أكبر من" (<<<):

>>>

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

python2.7

Python 2.7.12 (default, Nov 19 2016, 06:48:10) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

المخرجات تبيّن لنا أننا نستخدم الإصدار Python 2.7.12. إذا كان هذا هو الإصدار الافتراضي لبايثون 2، فيمكننا أيضًا الدخول إلى سطر الأوامر التفاعلي باستخدام الأمر python2.

بالمقابل، يمكننا استدعاء إصدار بايثون 3 الافتراضي باستخدام الأمر التالي:

python3

Python 3.5.2 (default, Nov 17 2016, 17:05:23) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

يمكن أيضًا أن نفتح سطر الأوامر التفاعلي أعلاه باستخدام الأمر python3.5.

بعد تشغيل سطر الأوامر التفاعلي لبايثون، يمكننا المضي قدمًا والبدء في العمل.

العمل في سطر أوامر بايثون التفاعلي

يقبل مترجم بايثون التفاعلي (Python interactive interpreter) قواعد لغة بايثون، والتي تضعها بعد البادئة <<<.

يمكننا، على سبيل المثال، إنشاء متغير وإسناد قيمة له بالشكل التالي:

>>> birth_year = 1868

بمجرد تعيين قيمة العدد الصحيح 1868 إلى المتغير birth_year، سنضغط على زر الإدخال ونحصل على سطر جديد يبدأ بثلاث علامات "أكبر من" (<<<):

>>> birth_year = 1868
>>>

يمكننا الاستمرار في تعيين المتغيرات، وإجراء الحسابات الرياضياتية:

>>> birth_year = 1868
>>> death_year = 1921
>>> age_at_death = death_year - birth_year
>>> print(age_at_death)
53
>>>

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

يمكنك أيضًا استخدام سطر الأوامر التفاعلي كآلة حاسبة:

>>> 203 / 20
10.15
>>>

هنا، قسمنا العدد الصحيح 203 على 20، نحصل على الناتج 10.15.

تعدد الأسطر

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

الشيفرة التالية تعيّن قيمتي متغيّرين، ثم تستخدم عبارة شرطية لتحديد ما يجب طباعته:

>>> sammy = 'Sammy'
>>> shark = 'Shark'
>>> if len(sammy) > len(shark):
...     print('Sammy codes in Java.')
... else:
...     print('Sammy codes in Python.')
... 
Sammy codes in Python.
>>>

في هذه الحالة، طولا السلسلتين النصيتين متساويان، لذلك يتم تنفيذ العبارة else.

لاحظ أنك ستحتاج إلى الحفاظ على مسافة بادئة بايثون (Python indenting) المؤلفة من أربعة مسافات بيضاء، وإلا سيُطلق خطأٌ:

>>> if len(sammy) > len(shark):
... print('Sammy codes in Java.')
  File "<stdin>", line 2
    print('Sammy codes in Java.')
        ^
IndentationError: expected an indented block
>>>

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

استيراد الوحدات

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

>>> import matplotlib
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named 'matplotlib'

في الحالة أعلاه، لم تكن الوحدة matplotlib متاحة في بيئة البرمجة الحالية.

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

(my_env) sammy@ubuntu:~/environments$ pip install matplotlib

Collecting matplotlib
  Downloading matplotlib-2.0.2-cp35-cp35m-manylinux1_x86_64.whl (14.6MB)
...
Installing collected packages: pyparsing, cycler, python-dateutil, numpy, pytz, matplotlib
Successfully installed cycler-0.10.0 matplotlib-2.0.2 numpy-1.13.0 pyparsing-2.2.0 python-dateutil-2.6.0 pytz-2017.2

بمجرد تثبيت الوحدة matplotlib هي وجميع تبعياتها بنجاح، يمكنك العودة إلى المترجم التفاعلي:

(my_env) sammy@ubuntu:~/environments$ python

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

الخروج من سطر أوامر بايثون التفاعلي

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

اختصار لوحة المفاتيح هو CTRL+D في أنظمة *نيكس، أو CTRL+Z ثم CTRL في أنظمة ويندوز، وبذلك ستخرج من سطر الأوامر، ويعيدك إلى البيئة الطرفية الأصلية:

...
>>> age_at_death = death_year - birth_year
>>> print(age_at_death)
53
>>> 
sammy@ubuntu:~/environments$

بدلًا من ذلك، الدالة quit()‎ ستنهي سطر الأوامر التفاعلي، وتعيدك إلى بيئة المحطة الطرفية الأصلية التي كنت فيها سابقًا:

>>> octopus = 'Ollie'
>>> quit()
sammy@PythonUbuntu:~/environments$

في حال استخدام الدالة quit()‎، فستُسجَّل في ملف التأريخ (history file)، بالمقابل لن يُسجّل اختصار لوحة المفاتيح CTRL+D ذلك:

# /home/sammy/.python_history الملف 
...
age_at_death = death_year - birth_year
print(age_at_death)
octopus = 'Ollie'
quit()

يمكن إنهاء مترجم بايثون بكلا الطريقتين، فاختر ما يناسبك.

الاطلاع على التأريخ

من فوائد سطر الأوامر التفاعلي أنّ جميع أوامرك تؤرَّخ في الملف ‎.python_history في أنظمة *ينكس، بحيث يمكنك الاطلاع عليها في أيّ محرر نصي، مثل nano:

nano ~/.python_history

بمجرد فتحه باستخدام محرر نصوص، سيبدو ملف تأريخ بايثون الخاص بك على هذا النحو:

# /home/sammy/.python_history الملف 
import pygame
quit()
if 10 > 5:
    print("hello, world")
else:
    print("nope")
sammy = 'Sammy'
shark = 'Shark'
...

بمجرد الانتهاء من ملفك، يمكنك الضغط على CTRL+X للخروج.

من خلال تتبع الأحداث المُؤرَّخة في بايثون، يمكنك الرجوع إلى الأوامر والتجارب السابقة، ونسخ ولصق أو تعديل الشيفرة لاستخدامها في الملفات البرمجية أو في Jupyter Notebook.

الخلاصة

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

لتنقيح (Debug) ملفات البرمجة في بايثون، يمكنك استخدام الوحدة code لفتح مترجم تفاعلي داخل ملف، وسنتحدث عن ذلك بالتفصيل في الدرس التالي: كيفية تنقيح بايثون باستخدام سطر الأوامر التفاعلي.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Work with the Python Interactive Console لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة اللاحقة: كيفية كتابة التعليقات في بايثون 3
• المقالة السابقة: كيف تكتب أول برنامج لك في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

كتابة برنامج يطبع العبارة "مرحبا بالعالم!‎" وتنفيذه هو أحد التقاليد الأساسية في مجال البرمجة، ويشكل أول برنامج بسيط وكامل للمبتدئين، وكذلك يُعدُّ اختبارًا لأنظمة وبيئات البرمجة، كما يعطي البرنامج فكرة عن الصياغة الأساسية للغات البرمجة.

ستتعلم في هذه المقالة كيفية كتابة برنامج "مرحبا بالعالم!" في بايثون 3.

المتطلبات الأساسية

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

مرحلة كتابة البرنامج

لكتابة البرنامج "مرحبا بالعالم!‎"، سننشئ ملفًا جديدًا باسم hello.py، ثم نفتحه بمحرر نصوص لسطر الأوامر، (مثل nano الموجود على أنظمة لينكس):

nano hello.py

إن لم يكن لديك المُحرِّر nano، فأنشئ الملف hello.py وافتحه باستعمال أي محرِّر موجود على نظام التشغيل لديك (مثل المفكرة على أنظمة ويندوز).

بمجرد فتح الملف النصي في نافذة الطرفية (أو محرِّر النصوص)، سنقوم بكتابة برنامجنا فيه وذلك بكتابة التعليمة البرمجية التالية:

print("مرحبا بالعالم!‎")

دعنا نشرّح هذه التعليمة.

print()‎ هي دالة (function) تخبر الحاسوب بتنفيذ إجراء ما. نعرف أنَّها دالة لأنها تستخدم الأقواس. تطلب print()‎ من بايثون أن يعرض أو يخرج ما نضعه بين القوسين. بشكل افتراضي، ستُعرَض المُخرجات في نافذة الطرفية عند تنفيذ البرنامج.

بعض الدوال، مثل print()‎، هي دوال مُدمجة (built-in) في بايثون بشكل افتراضي. هذه الدوال المدمجة متوفرة لنا دائمًا لاستخدامها في برامجنا. يمكننا أيضًا تعريف دوالنا الخاصة وبناءها من عناصر أخرى.

داخل قوسي الدالة print()‎ توجد سلسلة من الأحرف - مرحبا بالعالم!‎‎ - محاطة بعلامتي اقتباس. وهذه الأحرف الموضوعة بين علامات الاقتباس تُسمى سلاسل نصية (strings) وهي أحد أنواع البيانات التي سنتعرف عليها لاحقًا.

بعد الانتهاء من كتابة البرنامج، يمكنك الخروج من nano عن طريق الضغط على ctrl+x، وعندما يُطلب منك حفظ الملف، اضغط على y.

بعد الخروج من المُحرِّر nano، ستعود إلى نافذة الطرفية.

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

مرحلة تنفيذ البرنامج

بعد الانتهاء من كتابة برنامج "مرحبا بالعالم!‎"، فنحن جاهزون لتنفيذه. سنستخدم الأمر python3 معقوبًا باسم ملف البرنامج:

python3 hello.py

سيعرض برنامج hello.py الذي أنشأته للتو المخرجات التالية على نافدة الطرفية:

مرحبا بالعالم!‎

دعني أشرح لك ما فعله البرنامج بمزيد من التفصيل.

في الشيفرة البرمجية، مررنا السلسلة النصية مرحبا بالعالم!‎‎ إلى الدالة print()‎ التي وظيفتها طباعة ما يُمرَّر إليها على مجرى الخرج (نافذة الطرفية في حالتنا هذه). في هذا المثال، السلسلة النصية مرحبا بالعالم!‎‎ تُسمى أيضًا وسيطًا (argument)، نظرًا لأنها قيمة مُمرّرة إلى دالة. علامتا الاقتباس اللتان تحيطان بالسلسلة النصية مرحبا بالعالم!‎‎ لن تُطبعا على الشاشة لأنهما تُستخدمان لإعلام بايثون بأنّهما تحتويان على سلسلة نصية. تُحدِّد علامتا الاقتباس مُبتدأ السلسلة النصية ومنتهاها.

بعد تنفيذ البرنامج، يمكنك الآن التأكد من أنّك نجحت في تثبيت بايثون 3، وأنّ البرنامج مكتوب ومُصَاغ صياغةً صحيحة.

الخلاصة

تهانينا! لقد أتممت كتابة أول برنامج لك، برنامج "مرحبا بالعالم!‎"، في بايثون 3. من الآن وصاعدًا، يمكنك استخدام الدالة print()‎ لعرض أية عبارات نصية أو قيم أخرى، ويمكنك أيضًا إنشاء ملفات برامج جديدة وتنفيذها بالطريقة ذاتها. لتعلم المزيد حول لغة بايثون، ننصحك بمتابعة سلسلة مقالات عن كيفية البرمجة في بايثون 3، والتي تأخذك خطوةً بخطوة لتعلم كيفية تثبيت بايثون وإعداد بيئة البرمجة، إضافةً إلى المفاهيم الأساسيات للغة، وأنواع البيانات والدوال والأصناف والبرمجة الكائنية وغيرها من المفاهيم؛ كما وفرنا دورةً تعليمية شاملةً حول تعلم التطوير واحترافه عن طريق لغة بايثون، وذلك انطلاقًا من الصفر إلى الاحتراف، وهذا في دورة تطوير تطبيقات باستخدام لغة بايثون، التي تمكّنك من تعلّم التطوير بلغة بايثون للتطبيقات ولمواقع الويب بالاعتماد على النظريات السليمة والتطبيق العملي والدعم المباشر.

ترجمة -وبتصرّف- للمقال How To Write Your First Python 3 Program لصاحبته Lisa Tagliaferri

اقرأ أيضًا

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

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

فهرس هذا الدرس -لسهولة الانتقال إلى نظام التشغيل الذي تريده- هو:

• كيفية تثبيت بايثون 3 وإعداد بيئة برمجية على أوبنتو 16.04
• كيفية تثبيت بايثون 3 وإعداد بيئة برمجية على أوبنتو 18.04
• كيفية تثبيت بايثون 3 وإعداد بيئة برمجية على ديبيان 8
• كيفية تثبيت بايثون 3 وإعداد بيئته البرمجية على CentOS 7
• كيفية تثبيت بايثون 3 وإعداد بيئته البرمجية على macOS
• كيفية تثبيت بايثون 3 وإعداد بيئته البرمجية على ويندوز 10

الأمور التي سنسلط الضوء عليها هي: تثبيت بايثون 3 على نظام تشغيلك ثم إعداد بيئته البرمجية. تتمثل عملية تهيئة البيئة البرمجية بإعداد بيئة وهمية تمكِّنك من إنشاء مساحة معزولة في حاسوبك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه يملك مجموعة من الاعتماديات (dependencies) والتي لن تؤثِّر على غيرها من المشاريع. يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.

بعد تثبيت بايثون وإكمال إعداد البيئة الوهمية، سنعلمك كيفية إنشاء برنامجٍ بسيطٍ يعرض العبارة «Hello World!‎» (أهلًا بالعالم!) الشهيرة، وبهذا سنتحقق من عمل البيئة عملًا صحيحًا، وستصبح آنذاك طريقة إنشاء برامج بايثون وتنفيذها مألوفةً لديك مما يمهد الطريق لكتابة وتنفيذ مشاريع بايثون اللاحقة.

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

كيفية تثبيت بايثون 3 وإعداد بيئة برمجية في أوبنتو 16.04

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

كيفية تثبيت بايثون 3 وإعداد بيئة برمجية على أوبنتو 18.04

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

كيفية تثبيت بايثون 3 وإعداد بيئة برمجية على ديبيان 8

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

كيفية تثبيت بايثون 3 وإعداد بيئته البرمجية على CentOS 7

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

كيفية تثبيت بايثون 3 وإعداد بيئته البرمجية على macOS

إن كان نظام تشغيلك هو macOS، فهذا الدرس هو لك. ستتلعم فيه خطوةً بخطوة كيفية تثبيت بايثون 3 على macOS، وتثبيت بيئتها البرمجية عبر سطر الأوامر، ولا تقلق إن لم يكن لديك أدنى فكرة عن استعمال سطر الأوامر. بدايةً، يشرح المقال كيفية تثبيت Xcode -هي بيئة تطوير متكاملة (IDE)- ثم تثبيت وإعداد Homebrew استعدادًا لتثبيت بايثون 3. ينتقل بعدها إلى إعداد البيئة الوهمية وإنشاء وتنفيذ برنامج بسيط (أشرنا إليه في آنفًا).

كيفية تثبيت بايثون 3 وإعداد بيئته البرمجية على ويندوز 10

إن كنت من مستخدمي نظام التشغيل الشهير ويندوز، فقد أتيت إلى الدرس الصحيح. سيُرشِدُك هذا الدرس خطوةً بخطوة إلى تثبيت بايثون 3 في ويندوز 10، وتهيئة بيئته البرمجية عبر سطر الأوامر. الخطوة الأولى لإنجاز ذلك هي فتح وإعداد PowerShell -برنامج من ميكروسوفت يوفر واجهة سطر الأوامر- ثم تثبيت مدير الحزم Chocolatey وذلك من أجل تثبيت بايثون 3. يُعرِّج بعدها على إعداد البيئة الوهمية وإنشاء برنامج بسيط وتنفيذه (أشرنا إليه في آنفًا).

اقرأ أيضًا

•  الدرس التالي: كيف تكتب أول برنامج لك في بايثون 3
• الدرس السابق: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• تعرف على أبرز مميزات لغة بايثون
• كتاب البرمجة بلغة بايثون

بايثون هي لغةٌ سهلة القراءة ومتنوعة ومتعددة الاستخدامات، وغالبًا ما تُستخدم في كتابة السكربتات (scripting) والأتمتة وتحليل البيانات وتعلم الآلة (machine learning) والتطوير الخلفي (back-end development).

ظهرت بايثون سنة 1991، واستوحي اسمها من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وبسيطة الإعداد، وجعل طريقة كتابتها مباشرة، مع توفير تقرير مباشر عند حدوث أخطاء. وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة. إصدار بايثون 3 هو الإصدار الحالي من اللغة ويُعدُّ مستقبل بايثون.

سيُرشِدُك هذا الدرس خطوةً بخطوة إلى كيفية تثبيت بايثون 3 في macOS، وتثبيت بيئة برمجة عبر سطر الأوامر.

المتطلبات المسبقة

لمتابعة هذه المقالة، يجب أن تملك جهازًا عليه نظام macOS متصل بالشبكة مع صلاحيات مدير (administrative access).

إذا لم تكن لك خبرة في التعامل مع بيئة النافذة الطرفية، فيمكنك مطالعة المقالة "مدخل إلى طرفيّة لينكس Linux Terminal".

الخطوة الأولى: فتح نافذة الطرفية

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

طرفية ماك (macOS Terminal) هي تطبيق يمكنك استخدامه للدخول إلى واجهة سطر الأوامر. مثل التطبيقات الأخرى، ستجد تطبيق الطرفية بالذهاب إلى Finder، وفتح المجلد Applications، ثم الذهاب إلى المجلد Utilities، ثم النقر المزدوج على Terminal لفتحه. أو يمكنك استخدام Spotlight عبر الضغط على الزرّين command و spacebar للعثور على Terminal بكتابته في المربع الذي سيظهر.

هنالك الكثير من الأوامر التي عليك تعلمها لكي تتمكن من الاستفادة منه. هنالك مقالات في أكاديمية حسوب (كدرس مدخل إلى طرفيّة لينكس Linux Terminal) ستعلمك أساسيات سطر الأوامر، وهنالك كتاب «سطر أوامر لينكس» الذي يُعتَبر مرجعًا لطريقة التعامل مع سطر الأوامر في لينكس، والذي يشبه نظيره في ماك.

الخطوة الثانية: تثبيت Xcode

Xcode هي بيئة تطوير متكاملة (IDE) تتألف من أدوات تطوير البرامج لنظام التشغيل MacOS. قد يكون Xcode مثبتًا عندك سلفًا. للتحقق من ذلك، اكتب في نافذة الطرفية ما يلي:

xcode-select -p

إن حصلت على المخرجات التالية، فهذا يعني أنّ مثبت Xcode:

/Library/Developer/CommandLineTools

إن تلقيت خطأ، فتثّبت Xcode من المتجر App Store واعتمد الخيارات الافتراضية.

بعد تثبيت Xcode، ارجع إلى النافذة الطرفية. ثم ثبّت التطبيق Command Line Tools عن طريق كتابة:

xcode-select --install

عند هذه المرحلة، يكون قد تم تثبيت Xcode، والتطبيق Command Line Tools الخاص به، ونحن الآن مستعدون لتثبيت مدير الحزم Homebrew.

الخطوة الثالثة: تثبيت وإعداد Homebrew

في حين أنّ طرفية OS X تتمتع بالكثير من وظائف طرفية لينكس وأنظمة يونيكس الأخرى، إلا أنها لا تأتي بمدير حزم جيد. مدير الحزم (package manager) هو مجموعة من أدوات البرمجيات التي تعمل على أتمتة عمليات التثبيت، بما في ذلك التثبيت الأولي للبرامج، وترقيتها، وإعدادها، وإزالتها عند الحاجة. تحفظ هذه الأدوات التثبيتات في موقع مركزي، ويمكنها صيانة جميع حزم البرامج على النظام وفق تنسيقات (formats) معروفة. توفر Homebrew لنظام التشغيل OS X نظام إدارة حزم مجاني ومفتوح المصدر يبسط عملية تثبيت البرنامج.

لتثبيت Homebrew، اكتب في نافذة الطرفية ما يلي:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

تم تطوير Homebrew عبر روبي، لذلك سيعدّل مسار روبي على جهازك. يسحب الأمر curl السكربت من عنوان URL المحدد. سيوضح ذلك السكربت ما سيفعله، ثم يوقف العملية ليطلب منك التأكيد. يوفر لك هذا الكثير من الملاحظات حول ما سيفعله السكربت في نظامك، ويمنحك الفرصة للتحقق من العملية.

لاحظ أنك عند إدخال كلمة المرور فلن تعرض الطرفية المحارف التي تكتبها، ولكنها ستُسجّل، بعد إدخال كلمة المرور اضغط على الزر return. واضغط على الحرف y إن طُلِب منك تأكيد التثبيت.

لنلق نظرة على الرايات (flags) المرتبطة بالأمر curl:

• تخبر الرايتان ‎-f أو ‎--fail الطرفية بعدم إعطاء مخرجات على هيئة مستند HTML عند حدوث أخطاء في الخادم.
• تُصمِت الرايتان ‎-s أو ‎--silent الأمر curl، بمعنى أنه لن يعرض معلومات التقدم، وعند جمعها مع الرايتين ‎-S أو ‎--show-error، ستجعل curl تُظهر رسالة خطأ في حال الفشل.
• تطلب الرايتان ‎-L أو ‎--location من curl إعادة الطلبية (request) إلى مكان جديد إذا أبلغ الخادم بأنّ الصفحة المطلوبة قد نُقِلت إلى موقع أخر.

بمجرد اكتمال عملية التثبيت، سنضع مجلد Homebrew في أعلى متغير البيئة PATH. سيضمن ذلك أن يتم استدعاء عمليات تثبيت Homebrew عبر الأدوات التي قد يختارها نظام التشغيل Mac OS X تلقائيًا، والتي قد تتعارض مع بيئة التطوير التي تنشئها.

يجب عليك إنشاء أو فتح الملف ‎~/.bash_profile باستخدام محرر نصوص سطر الأوامر nano باستخدام الأمر nano:

nano ~/.bash_profile

بعد فتح الملف في نافذة الطرفية، اكتب ما يلي:

export PATH=/usr/local/bin:$PATH

لحفظ التغييرات، اضغط على المفتاح control والحرف o بالتزامن، وعند مطالبتك بالتأكيد، اضغط على المفتاح return. يمكنك الآن الخروج من nano عن طريق الضغط على المفتاح control والحرف x بالتزامن.

لتفعيل هذه التغييرات، اكتب في نافذة الطرفية:

source ~/.bash_profile

ستصير الآن التغييرات التي أجريتها على متغير البيئة PATH فعالة.

يمكننا التحقق من أنّ Homebrew قد ثُبِّت بنجاح عن طريق كتابة:

brew doctor

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

Your system is ready to brew.

خلاف ذلك، قد تحصل على تنبيه يدعوك إلى تنفيذ أمر آخر مثل brew update للتأكد من أنّ Homebrew محدّث.

بمجرد أن تصبح Homebrew جاهزة، يمكنك تثبيت بايثون 3.

المرحلة الرابعة: تثبيت بايثون 3

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

brew search python

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

app-engine-python          micropython                python3                 
boost-python               python                     wxpython                 
gst-python                 python-markdown            zpython                  
homebrew/apache/mod_python               homebrew/versions/gst-python010        
homebrew/python/python-dbus              Caskroom/cask/kk7ds-python-runtime     
homebrew/python/vpython                  Caskroom/cask/mysql-connector-python

سيكون بايثون 3 (python3) من بين العناصر المدرجة في القائمة. لذلك دعنا نثبّتها:

brew install python3

ستعرض لك نافذة الطرفية ملاحظات بشأن عملية تثبيت بايثون 3، وقد يستغرق الأمر بضع دقائق قبل اكتمال التثبيت.

إلى جانب بايثون 3، ستثبّت Homebrew الأدوات pip و setuptools و wheel.

سنستخدم pip، وهي أداةٌ تعمل مع لغة بايثون تُثَبِّت وتدير الحزم البرمجية التي قد نحتاج إلى استخدامها في تطوير مشاريعنا. يمكنك تعلم المزيد عن الوحدات والحزم التي يمكنك تثبيتها بالأداة pip بقراءة المقالة كيفية استيراد الوحدات في بايثون 3 من هذه السلسلة.

يمكن تثبيت حزم بايثون بكتابة ما يلي:

pip3 install package_name

عليك وضع اسم الحزمة أو المكتبة التابعة لبايثون مكان package_name مثل Django لتطوير الويب، أو NumPy لإجراء الحسابات العلمية. لذا، إن شئتَ تنزيل NumPy فيمكنك تنفيذ الأمر pip3 install numpy.

تسهّل الأداة setuptools تحزيم مشاريع بايثون، أما wheel فهي تنسيق حُزم (built-package format) لبايثون يمكنه تسريع إنتاجية البرامج عن طريق تقليل عدد المرات التي تحتاج فيها إلى التصريف.

بعد إكمال العملية، يمكننا التحقق من إصدار بايثون 3 المُثبّت في النظام بكتابة:

python3 --version

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

لتحديث إصدار بايثون 3، يمكنك أولاً تحديث Homebrew، ثم تحديث بايثون:

brew update
brew upgrade python3

من الممارسات الجيدة تحديث إصدار بايثون الذي تعمل به من حين لآخر.

الخطوة الخامسة: إعداد بيئة افتراضية

الآن بعد تثبيت Xcode و Homebrew وبايثون، يمكننا المضي قدمًا لإنشاء بيئة البرمجة خاصتنا.

تُمكِّنك البيئات الافتراضية من إنشاء مساحة معزولة في حاسوبك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه ستكون له اعتماديّاته (dependencies) الخاصة به، والتي لن تؤثِّر على غيره من المشاريع.

يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون، وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون. وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.

يمكنك ضبط أيّ عددٍ تشاء من البيئات الافتراضية، وكل بيئة ستكون ممثلة بمجلد في حاسوبك يحتوي على عدد من السكربتات.

اختر المجلد الذي تريد أن تضع فيه بيئات بايثون، أو يمكنك إنشاء مجلد جديد باستخدام الأمر mkdir كما يلي:

mkdir environments
cd environments

بعد أن انتقلتَ إلى المجلد الذي تريد احتواء البيئات فيه، تستطيع الآن إنشاء بيئة جديدة بتنفيذ الأمر التالي:

python3.6 -m venv my_env

سيُنشِئ هذا الأمر مجلدًا جديدًا (في هذه الحالة يُسمى my_env) فيه بعض الملفات:

• يشير الملف pyvenv.cfg إلى توزيعة بايثون التي استخدمتها لتنفيذ الأمر.
• يحتوي المجلد الفرعي lib نسخة من إصدار بايثون، ويحتوي على مجلد يسمى site-packages، والذي سيكون فارغًا في البداية، ولكنه سيُستخدم لتخزين وحدات الطرف الثالث التي ستثبّتها.
• المجلد الفرعي include يُصرِّف (packages) الحزم.
• يحتوي المجلد الفرعي bin نسخة من رُقامة بايثون (Python binary) جنبًا إلى جنب مع سكربت التفعيل (activate shell script) الذي سيُستخدم

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

عليك تفعيل البيئة لاستخدامها، وذلك بكتابة الأمر التالي الذي سيُنفِّذ سكربت التفعيل:

source my_env/bin/activate

يجب أن تظهر الآن سابقةٌ (prefix) في المِحث (prompt) والتي هي اسم البيئة المستخدمة، وفي حالتنا هذه يكون اسمها my_env، وهذا يعني أننا لن سنستخدم إلا إعدادات وحزم هذه البيئة عند إنشاء مشاريع جديدة.

ملاحظة: يمكنك داخل البيئة الافتراضية أن تستخدم الأمر python بدلًا من python3 والأمر pip بدلًا من pip3 إن شئتَ. أما إذا كنتَ تستخدم بايثون 3 خارج البيئة الافتراضية، فيجب عليك حينها استخدام python3 و pip3 حصرًا. لأنّ python وpip ستستدعيان إصدارًا قديمًا من بايثون.

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

الخطوة الثالثة: إنشاء برنامج بسيط

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

علينا أولًا تشغيل محرر ملفات نصية لإنشاء ملف جديد، وليكن المحرر nano الذي يعمل من سطر الأوامر:

(my_env) sammys-MBP:~ sammy$ nano hello.py

بعد فتح الملف في نافذة الطرفية، سنكتب البرنامج الخاص بنا:

print("مرحبا بالعالم!")

أغلق محرر nano بالضغط على Ctrl+x ثم اضغط على y عندما يسألك عن حفظ الملف.

بعد أن يُغلَق المحرر nano وتعود إلى سطر الأوامر، حاول تنفيذ البرنامج:

(my_env) sammys-MBP:~ sammy$  python hello.py

سيؤدي برنامج hello.py الذي أنشأتَه إلى طباعة الناتج التالي في الطرفية:

مرحبا بالعالم!

للخروج من البيئة، اكتب الأمر deactivate وستعود إلى مجلدك الأصلي.

الخلاصة

تهانينا! لقد ضبطتَ الآن بيئة تطويرٍ للغة بايثون 3 في نظام Mac OS X، حان الآن الوقت للتعمق بلغة بايثون وإنشاء برامج رائعة! بالتوفيق.

ترجمة -وبتصرّف- للمقال How To Install Python 3 and Set Up a Local Programming Environment on macOS لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيف تكتب أول برنامج لك
• المقالة السابقة: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

بايثون هي لغةٌ سهلة القراءة ومتنوعة ومتعددة الاستخدامات، وغالبًا ما تُستخدم في كتابة السكربتات (scripting) والأتمتة وتحليل البيانات وتعلم الآلة (machine learning) والتطوير الخلفي (back-end development).

ظهرت بايثون سنة 1991، واستوحي اسمها من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وبسيطة الإعداد، وجعل طريقة كتابتها مباشرة، مع توفير تقرير مباشر عند حدوث أخطاء. وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة. إصدار بايثون 3 هو الإصدار الحالي من اللغة ويُعدُّ مستقبل بايثون.

سيُرشِدُك هذا الدرس خطوةً بخطوة إلى كيفية تثبيت بايثون 3 على لينيكس، وتثبيت بيئة برمجة عبر سطر الأوامر. صحيحٌ أنَّ هذا الدرس يشرح عملية التثبيت في دبيان 8، إلا أنَّ المفاهيم الأساسية فيه تنطبق على جميع توزيعات دبيان لينيكس (Debian Linux).

المتطلبات المسبقة

لمتابعة هذه المقالة، يجب أن تملك صلاحيات مستخدم غير جذري (non-root user ) مع امتيازات sudo على توزيعة دبيان 8، أو توزيعة أخرى من دبيان لينيكس (Debian Linux).

إذا لم تكن لك خبرة في التعامل مع بيئة النافذة الطرفية، فيمكنك مطالعة المقالة "مدخل إلى طرفيّة لينكس Linux Terminal".

الخطوة الأولى: إعداد بايثون 3

سنُثبِّت ونضبط بايثون عبر سطر الأوامر، والذي هو طريقةٌ غيرُ رسوميةٍ للتعامل مع الحاسوب، فبدلًا من الضغط على الأزرار، ستكتب نصًّا وتعطيه للحاسوب لينفذه، وسيُظهِر لك ناتجًا نصيًا أيضًا. يمكن أن يساعدك سطر الأوامر على تعديل أو أتمتة مختلف المهام التي تنجزها على الحاسوب يوميًا، وهو أداةٌ أساسيةٌ لمطوري البرمجيات، وهنالك الكثير من الأوامر التي عليك تعلمها لكي تتمكن من الاستفادة منه. هنالك مقالات في أكاديمية حسوب (كدرس مدخل إلى طرفيّة لينكس Linux Terminal) ستعلمك أساسيات سطر الأوامر، وهنالك كتاب «سطر أوامر لينكس» الذي يُعتَبر مرجعًا لطريقة التعامل مع سطر الأوامر.

ستجد تطبيق «Terminal» (البرنامج الذي تستعمله للوصول إلى سطر الأوامر) بفتح القائمة في الزاوية السفلى اليسرى من الشاشة ثم كتابة «terminal» في شريط البحث، ثم الضغط على أيقونة التطبيق التي ستظهر بعدئذٍ. أو يمكنك أن تضغط على Ctrl+Alt+T في لوحة المفاتيح بنفس الوقت لتشغيل تطبيق الطرفية Terminal.

في دبيان 8 والإصدارات الأخرى من دبيان لينكس، ستجد كلًا من بايثون 3 وبايثون 2 مثبتين مسبقًا. للتأكد من أنّ إصدارات بايثون حديثة، سنحدّث النظام ونرقّيه باستخدام الأمر apt-get:

sudo apt-get update
sudo apt-get -y upgrade

الخيار ‎-y يعني أنَّك توافق على تثبيت جميع الحزم القابلة للتحديث، لكن قد تحتاج إلى تأكيد ذلك عند تحديث النظام وذلك اعتمادًا على الحزم التي ستُحدَّث، ونسخة لينكس.

بعد إكمال العملية، يمكننا التحقق من إصدار بايثون 3 المُثبّت في النظام بكتابة:

python3 -V

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

Python 3.5.2

لإدارة الحزم البرمجية الخاصة ببايثون، سنثبّت pip، وهي أداةٌ تعمل مع لغة بايثون تُثَبِّت وتدير الحزم البرمجية التي قد نحتاج إلى استخدامها في تطوير مشاريعنا. يمكنك تعلم المزيد عن الوحدات والحزم التي يمكنك تثبيتها بالأداة pip بقراءة المقالة كيفية استيراد الوحدات في بايثون 3 من هذه السلسلة:

sudo apt-get install -y python3-pip

يمكن تثبيت حزم بايثون بكتابة ما يلي:

pip3 install package_name

حيث عليك وضع اسم الحزمة أو المكتبة التابعة لبايثون مكان package_name مثل Django لتطوير الويب، أو NumPy لإجراء الحسابات العلمية. لذا، إن شئتَ تنزيل NumPy فيمكنك تنفيذ الأمر pip3 install numpy.

هناك عدة حزم وأدوات تطوير أخرى يجب تثبيتها للتأكد من أنّ بيئة البرمجة جاهزة:

sudo apt-get install build-essential libssl-dev libffi-dev python-dev

بعد أن انتهينا من ضبط بايثون وتثبيت pip، يمكننا الآن إنشاء «بيئة افتراضية» (virtual environment) لمشاريعنا.

الخطوة الثانية: إعداد بيئة افتراضية

تُمكِّنك البيئات الافتراضية من إنشاء مساحة معزولة في حاسوبك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه ستكون له اعتماديّاته (dependencies) الخاصة به، والتي لن تؤثِّر على غيره من المشاريع.

يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون، وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون. وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.

يمكنك ضبط أيُّ عددٍ تشاء من البيئات الافتراضية، وكل بيئة ستكون ممثلة بمجلد في حاسوبك يحتوي على عدد من السكربتات.

هناك عدة طرق لإعداد بيئة برمجية في بايثون، لكننا سنستخدم وحدة (module) برمجية باسم venv، وهي جزءٌ من مكتبة بايثون 3 القياسية. سنثبّت venv على نظامنا بكتابة:

sudo apt-get install -y python3-venv

بعد إتمام التثبيت، فنحن جاهزون لإنشاء البيئات الافتراضية، يمكننا الآن إما اختيار مجلد نضع فيه بيئات بايثون، أو إنشاء مجلد جديد باستخدام الأمر mkdir كما يلي:

mkdir environments
cd environments

بعد أن انتقلتَ إلى المجلد الذي تريد احتواء البيئات فيه، تستطيع الآن إنشاء بيئة جديدة بتنفيذ الأمر الآتي:

python3.6 -m venv my_env

سيُنشِئ الأمر pyvenv مجلدًا جديدًا فيه بعض الملفات التي يمكن عرضها باستخدام الأمر ls:

ls my_env

ستظهر لك مخرجات شبيهة بالمخرجات التالية:

bin include lib lib64 pyvenv.cfg share

تعمل هذه الملفات مع بعضها لضمان أنَ تكون مشاريعك معزولةٌ عن سياق الآلة المحلية، لكي لا تختلط ملفات النظام مع ملفات المشاريع. وهذا أمرٌ حسنٌ لإدارة الإصدارات ولضمان أنَّ كل مشروع يملك وصولًا إلى الحزمٍ التي يحتاجها. تتوافر أيضًا Python Wheels، والتي هي صيغة بناء حزمٍ (built-package format) لبايثون، والتي يمكن أن تُسرِّع من تطوير البرامج بتقليل عدد المرات التي تحتاج فيها إلى تصريف (compile) المشروع، وهي موجودةٌ في كل المجلدات المُسمّاة lib.

عليك تفعيل البيئة لاستخدامها، وذلك بكتابة الأمر التالي الذي سيُنفِّذ سكربت التفعيل:

source my_env/bin/activate

يجب أن تظهر الآن سابقةٌ (prefix) في المِحث (prompt) والتي هي اسم البيئة المستخدمة، وفي حالتنا هذه يكون اسمها my_env، وقد يكون مظهر المِحَث مختلفًا في توزيعة دبيان، وذلك اعتمادًا على الإصدار المستخدم؛ لكن يجب أن تشاهد اسم البيئة بين قوسين في بداية السطر:

(my_env) sammy@sammy:~/environments$

ستسمح لك السابقة بمعرفة أنَّ البيئة my_env مفعلة حاليًا، وهذا يعني أننا سنستخدم إعدادات وحزم هذه البيئة عند إنشاء مشاريع جديدة.

ملاحظة: يمكنك داخل البيئة الافتراضية أن تستخدم الأمر python بدلًا من python3 والأمر pip بدلًا من pip3 إن شئتَ. أما إذا كنتَ تستخدم بايثون 3 خارج البيئة الافتراضية، فيجب عليك حينها استخدام python3 و pip3 حصرًا.

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

الخطوة الثالثة: إنشاء برنامج بسيط

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

علينا أولًا تشغيل محرر ملفات نصية لإنشاء ملف جديد، وليكن المحرر nano الذي يعمل من سطر الأوامر:

(my_env) sammy@sammy:~/environments$ nano hello.py

بعد فتح الملف في نافذة الطرفية، سنكتب البرنامج الخاص بنا:

print("مرحبا بالعالم!")

أغلق محرر nano بالضغط على Ctrl+x ثم اضغط على y عندما يسألك عن حفظ الملف.

بعد أن يُغلَق المحرر nano وتعود إلى سطر الأوامر، حاول تنفيذ البرنامج:

(my_env) sammy@sammy:~/environments$ python hello.py

سيؤدي برنامج hello.py الذي أنشأتَه إلى طباعة الناتج التالي في الطرفية:

مرحبا بالعالم!

للخروج من البيئة، اكتب الأمر deactivate وستعود إلى مجلدك الأصلي.

الخلاصة

تهانينا! لقد ضبطتَ الآن بيئة تطويرٍ للغة بايثون 3 في نظام لينكس دبيان، حان الآن الوقت للتعمق بلغة بايثون وإنشاء برامج رائعة! بالتوفيق.

ترجمة -وبتصرّف- للمقال How To Install Python 3 and Set Up a Local Programming Environment on Debian 8 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيف تكتب أول برنامج لك
• المقالة السابقة: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

بايثون هي لغةٌ سهلة القراءة ومتنوعة ومتعددة الاستخدامات، وغالبًا ما تُستخدم في كتابة السكربتات (scripting) والأتمتة وتحليل البيانات وتعلم الآلة (machine learning) والتطوير الخلفي (back-end development).

ظهرت بايثون سنة 1991، واستوحي اسمها من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وبسيطة الإعداد، وجعل طريقة كتابتها مباشرة، مع توفير تقرير مباشر عند حدوث أخطاء. وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة. إصدار بايثون 3 هو الإصدار الحالي من اللغة ويُعدُّ مستقبل بايثون.

سيُرشِدُك هذا الدرس خطوةً بخطوة إلى كيفية تثبيت بايثون 3 على CentOS 7، وتثبيت بيئة برمجة عبر سطر الأوامر.

المتطلبات المسبقة

لمتابعة هذه المقالة، يجب أن تملك صلاحيات مستخدم أساسي غير جذري (non-root superuser) على نظام CentOS 7 متصل بالشبكة.

إذا لم تكن لك خبرة في التعامل مع بيئة النافذة الطرفية، فيمكنك مطالعة المقالة "مدخل إلى طرفيّة لينكس Linux Terminal".

الخطوة الأولى: تحضير النظام

سنُثبِّت ونضبط بايثون عبر سطر الأوامر، إن كان نظام CentOS 7 يبدأ بسطح مكتب ذي واجهة مستخدم رسومية (GUI)، فيمكنك الدخول إلى سطر الأوامر بفتح القائمة، والدخول إلى Applications ثم Utilities ثم النقر على Terminal. هنالك مقالات في أكاديمية حسوب (كدرس مدخل إلى طرفيّة لينكس Linux Terminal) ستعلمك أساسيات سطر الأوامر، وهنالك كتاب «سطر أوامر لينكس» الذي يُعدُّ مرجعًا لطريقة التعامل مع سطر الأوامر.

سنستخدم أداة إدارة الحزم مفتوحة المصدر yum (اختصار للعبارة Yellowdog Updater Modified). هذه أداة شائعة الاستخدام لإدارة الحزم على أنظمة لينكس المستندة إلى Red Hat، مثل CentOS. ستتيح لك هذه الأداة تثبيت الحزم وتحديثها بسهولة، وكذلك إزالة الحزم من الجهاز.

قبل أن نبدأ التثبيت، دعنا نتأكد من أنّ لدينا أحدث إصدار من yum عبر تنفيذ الأمر التالي:

sudo yum -y update

الخيار ‎-y يعني أنَّك تدرك أنّك تحدث تغييرات، وذلك لمنع الطرفية من طلب تأكيد قبل تنفيذ الأمر.

سنثبّت الآن yum-utils، وهي حزمة من الأدوات والإضافات التي توسّع yum وتكمّلها:

sudo yum -y install yum-utils

أخيرًا، سنثبّت أدوات التطوير الخاصة بنظام CentOS، والتي تُستخدم لإنشاء وتصريف (compile) البرامج من الشيفرة المصدرية:

sudo yum -y groupinstall development

بمجرد تثبيت كل شيء، فنحن جاهزون لتثبيت بايثون 3.

المرحلة الثانية: تثبيت وإعداد بايثون 3

نظام CentOS مشتق من RHEL (اختصار للجملة Red Hat Enterprise Linux) ، والذي يركز على الثبات والاستقرار. ولهذا السبب، فلن تجد في هذا النظام إلا الإصدارات المستقرة والمُختبرة من التطبيقات والحزم القابلة للتنزيل، لذلك لن تجد على CentOS إلا الإصدار بايثون 2.

نظرًا لأننا نرغب في تثبيت أحدث إصدار مستقر من بايثون 3، فسنحتاج إلى تثبيت IUS (اختصار للعبارة Inline with Upstream Stable)، وهو مشروع مفتوح المصدر. يوفر IUS حزم Red Hat Package Manager ‏(RPM) لبعض الإصدارات الحديثة من البرامج المحددة.

سنثبت IUS عبر yum:

sudo yum -y install https://centos7.iuscommunity.org/ius-release.rpm

بعد الانتهاء من تثبيت IUS، يمكننا تثبيت أحدث إصدار من بايثون:

sudo yum -y install python36u

بعد إكمال العملية، يمكننا التحقق من نجاح عملية التثبيت بطلب إصدار بايثون بكتابة:

python3.6 -V

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

Python 3.6.1

لإدارة الحزم البرمجية الخاصة ببايثون، سنثبّت pip، وهي أداةٌ تعمل مع لغة بايثون تُثَبِّت وتدير الحزم البرمجية التي قد نحتاج إلى استخدامها في تطوير مشاريعنا. يمكنك تعلم المزيد عن الوحدات والحزم التي يمكنك تثبيتها بالأداة pip بقراءة المقالة كيفية استيراد الوحدات في بايثون 3 من هذه السلسلة:

sudo yum -y install python36u-pip

يمكن تثبيت حزم بايثون بكتابة ما يلي:

sudo pip3.6 install package_name

حيث عليك وضع اسم الحزمة أو المكتبة التابعة لبايثون مكان package_name مثل Django لتطوير الويب، أو NumPy لإجراء الحسابات العلمية. لذا، إن شئتَ تنزيل NumPy فيمكنك تنفيذ الأمر pip3.6 install numpy.

أخيرًا، سنحتاج إلى تثبيت الحزمة python36u-devel الخاصة بـ IUS، والتي توفر لنا مكتبات وملفات ترويسية (header files) ضرورية للتطوير على بايثون 3:

sudo yum -y install python36u-devel

سنستخدم الوحدة venv لإعداد «بيئة افتراضية» (virtual environment) لمشاريعنا.

الخطوة الثالثة: إعداد بيئة افتراضية

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

تُمكِّنك البيئات الافتراضية من إنشاء مساحة معزولة في حاسوبك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه ستكون له اعتماديّاته (dependencies) الخاصة به، والتي لن تؤثِّر على غيره من المشاريع.

يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون، وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون. وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.

يمكنك ضبط أيّ عددٍ تشاء من البيئات الافتراضية، وكل بيئة ستكون ممثلة بمجلد في حاسوبك يحتوي على عدد من السكربتات.

بعد إتمام التثبيت، فنحن جاهزون لإنشاء البيئات الافتراضية، يمكننا الآن إما اختيار مجلد نضع فيه بيئات بايثون، أو إنشاء مجلد جديد باستخدام الأمر mkdir كما يلي:

mkdir environments
cd environments

بعد أن انتقلتَ إلى المجلد الذي تريد احتواء البيئات فيه، تستطيع الآن إنشاء بيئة جديدة بتنفيذ الأمر الآتي:

python3.6 -m venv my_env

سيُنشِئ الأمر pyvenv مجلدًا جديدًا فيه بعض الملفات التي يمكن عرضها باستخدام الأمر ls:

ls my_env

ستظهر لك مخرجات شبيهة بالمخرجات التالية:

bin include lib lib64 pyvenv.cfg

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

عليك تفعيل البيئة لاستخدامها، وذلك بكتابة الأمر التالي الذي سيُنفِّذ سكربت التفعيل:

source my_env/bin/activate

يجب أن تظهر الآن سابقةٌ (prefix) في المِحث (prompt) والتي هي اسم البيئة المستخدمة، وفي حالتنا هذه يكون اسمها my_env:

(my_env) sammy@locahost:~/environments$

ستسمح لك السابقة بمعرفة أنَّ البيئة my_env مفعلة حاليًا، وهذا يعني أننا سنستخدم إعدادات وحزم هذه البيئة عند إنشاء مشاريع جديدة.

ملاحظة: يمكنك داخل البيئة الافتراضية أن تستخدم الأمر python بدلًا من python3.6 والأمر pip بدلًا من pip3.6 إن شئتَ. أما إذا كنتَ تستخدم بايثون 3 خارج البيئة الافتراضية، فيجب عليك حينها استخدام python3.6 و pip3.6 حصرًا.

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

الخطوة الرابعة: إنشاء برنامج بسيط

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

علينا أولًا تشغيل محرر ملفات نصية لإنشاء ملف جديد، وليكن المحرر vim:

(my_env) sammy@localhost:~/environments$ vim hello.py

بعد فتح الملف في نافذة الطرفية، اكتب الحرف i للدخول إلى وضع الإدراج (insert mode)، بعدها يمكننا كتابة البرنامج:

print("مرحبا بالعالم!")

الآن اضغط على الزر ESC للخروج من وضع الإدراج. بعد ذلك ، اكتب wq: ثم ENTER لحفظ الملف وإغلاقه.

نحن جاهزون الآن لتنفيذ البرنامج:

(my_env) sammy@localhost:~/environments$ python hello.py

سيؤدي برنامج hello.py الذي أنشأتَه إلى طباعة الناتج التالي في الطرفية:

مرحبا بالعالم!

للخروج من البيئة، اكتب الأمر deactivate وستعود إلى مجلدك الأصلي.

الخلاصة

تهانينا! لقد ضبطتَ الآن بيئة تطويرٍ للغة بايثون 3 في CentOS 7، حان الآن الوقت للتعمق بلغة بايثون وإنشاء برامج رائعة! بالتوفيق.

ترجمة -وبتصرّف- للمقال How To Install Python 3 and Set Up a Local Programming Environment on CentOS 7‎ لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيف تكتب أول برنامج لك
• المقالة السابقة: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

بايثون هي لغةٌ سهلة القراءة ومتنوعة ومتعددة الاستخدامات، وغالبًا ما تُستخدم في كتابة السكربتات (scripting) والأتمتة وتحليل البيانات وتعلم الآلة (machine learning) والتطوير الخلفي (back-end development).

ظهرت بايثون سنة 1991، واستوحي اسمها من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وبسيطة الإعداد، وجعل طريقة كتابتها مباشرة، مع توفير تقرير مباشر عند حدوث أخطاء. وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة. إصدار بايثون 3 هو الإصدار الحالي من اللغة ويُعدُّ مستقبل بايثون.

سيُرشِدُك هذا الدرس خطوةً بخطوة إلى كيفية تثبيت بايثون 3 في ويندوز 10، وتثبيت بيئة برمجة عبر سطر الأوامر.

المتطلبات المسبقة

لمتابعة هذه المقالة، يجب أن تملك جهازًا عليه نظام ويندوز 10 متصل بالشبكة مع صلاحيات مدير (administrative access).

الخطوة الأولى: فتح وإعداد PowerShell

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

PowerShell هي برنامج من ميكروسوفت يوفر واجهة سطر الأوامر. يمكن إجراء المهام الإدارية عبر تنفيذ الأصناف cmdlets، والتي تُنطَق "command-lets"، وهي أصناف متخصصة من الإطار ‎.NET يمكنها تنفيذ العمليات. جُعِلت PowerShell مفتوحة المصدر منذ أغسطس 2016، وصارت متوفرة الآن عبر ويندوز و أنظمة يونكس (بما في ذلك ماك ولينكس).

ستعثر على PowerShell بالنقر الأيمن على أيقونة Start في الركن الأيسر السفلي من الشاشة. عندما تنبثق القائمة، انقر على "Search"، ثم اكتب "PowerShell" في شريط البحث. عند تقديم خيارات لك، انقر بالزر الأيمن على تطبيق سطح المكتب "Windows PowerShell". اختر "Run as Administrator". عندما يظهر مربع حوار يسألك "Do you want to allow this app to make changes to your PC?"، انقر على "Yes".

بمجرد إتمام ذلك، سترى واجهة نصية تبدو كما يلي:

يمكننا تبديل مجلد النظام عن طريق كتابة الأمر التالي:

cd ~

بعد ذلك سننتقل إلى المجلد PS C:\Users\Sammy.

لمتابعة عملية التثبيت، سنعدّ بعض الأذونات من خلال PowerShell. تم إعداد PowerShell لتعمل في الوضع الأكثر أمانًا بشكل افتراضي، هناك عدة مستويات للأذونات، والتي يمكنك إعدادها باعتبارك مديرًا (administrator):

• Restricted: تمثل سياسة التنفيذ الافتراضية، وبموجب هذا الوضع، لن تتمكن من تنفيذ السكربتات، وستعمل PowerShell كصدفة تفاعلية (interactive shell) وحسب.

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

• RemoteSigned: ستمكّنك من تنفيذ السكربتات وملفات الإعداد المُنزّلة من الشبكة، والمُوقعة من قبل جهة موثوقة، مما يعني أنه من المحتمل أن تعرّض جهازك لخطر تنفيذ سكربتات ضارة إن كانت تلك السكربتات الموثوقة ضارة.
• Unrestricted: تسمح بتنفيذ جميع السكربتات وملفات الإعداد المُنزّلة من الشبكة بمجرد أن تؤكد أنك تدرك أنّ الملف مُنزّل من الشبكة. في هذه الحالة، التوقيعات الرقمية غير لازمة، مما يعني أنه من المحتمل أن تعرّض جهازك لخطر تنفيذ سكربتات غير موثوقة منزلة من الشبكة قد تكون ضارة.

سنستخدم سياسة التنفيذ RemoteSigned لتعيين الإذن للمستخدم الحالي، وهكذا سنسمح لبرنامج PowerShell بقبول السكربتات المُنزّلة التي نثق بها، ودون خفض كل دفاعاتنا وجعل الأذونات هشة كما هو الحال مع سياسة التنفيذ Unrestricted. سنكتب في PowerShell:

Set-ExecutionPolicy -Scope CurrentUser

ستطالبك PowerShell بتحديد سياسة التنفيذ، وبما أننا نريد استخدام RemoteSigned، فسنكتب:

RemoteSigned

بمجرد الضغط على الزر enter، ستُسأل عما إن كنت نريد تغيير سياسة التنفيذ. اكتب الحرف y لاختيار "نعم"، واعتماد التغييرات. يمكننا التحقق من نجاح العملية عن طريق طلب الأذونات الحالية في الجهاز عبر كتابة:

Get-ExecutionPolicy -List

ستحصل على مخرجات مشابهة لما يلي:

       Scope ExecutionPolicy
        ----- ---------------
MachinePolicy       Undefined
   UserPolicy       Undefined
      Process       Undefined
  CurrentUser    RemoteSigned
 LocalMachine       Undefined

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

الخطوة الثانية: تثبيت Chocolatey

مدير الحزم (package manager) هو مجموعة من أدوات البرمجيات التي تعمل على أتمتة عمليات التثبيت، بما في ذلك التثبيت الأولي للبرامج، وترقيتها، وإعدادها، وإزالتها عند الحاجة. تحفظ هذه الأدوات التثبيتات في موقع مركزي، ويمكنها صيانة جميع حزم البرامج على النظام وفق تنسيقات (formats) معروفة.

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

قبل تثبيت السكربت، دعنا نقرأه للتأكد من أنّ التغييرات التي سيجريها على الجهاز مقبولة. سنستخدم إطار العمل ‎.NET لتنزيل وعرض السكربت Chocolatey في نافذة الطرفية. سننشئ كائنًا WebClient يُسمى ‎$script‎‎ (يمكنك تسميته كما تريد طالما ستستخدم المحرف $ في البداية)، والذي يشارك إعدادات الاتصال بالشبكة مع المتصفح Internet Explorer:

$script = New-Object Net.WebClient

دعنا نلقي نظرة على الخيارات المتاحة لنا من خلال توصيل الكائن إلى الصنف Get-Member لإعادة جميع الأعضاء (الخاصيات والتوابع) الخاصة بكائن WebClient:

$script | Get-Member

سنحصل على المخرجات التالية:

. . .
DownloadFileAsync         Method     void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur...
DownloadFileTaskAsync     Method     System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa...
DownloadString            Method     string DownloadString(string address), string DownloadString(uri address) # التابع الذي سنستخدمه
DownloadStringAsync       Method     void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy...
DownloadStringTaskAsync   Method     System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy…
 . . .

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

$script.DownloadString("https://chocolatey.org/install.ps1")

بعد مطالعة السكربت، يمكننا تثبيت Chocolatey عن طريق كتابة ما يلي في PowerShell:

iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

تسمح لنا iwr أو Invoke-WebRequest التي تخص cmdlet باستخراج البيانات من الشبكة. سيؤدي هذا إلى تمرير السكربت إلى iex أو Invoke-Expression، والذي سينفذ محتويات السكربت، وتنفيذ سكربت التثبيت لمدير الحزم Chocolatey.

اسمح لبرنامج PowerShell بتثبيت Chocolatey. بمجرد تثبيته بالكامل، يمكننا البدء في تثبيت أدوات إضافية باستخدام الأمر choco.

إن احتجت إلى ترقية Chocolatey مستقبلًا، يمكنك تنفيذ الأمر التالي:

choco upgrade chocolatey

بعد تثبيت مدير الحزم، يمكننا متابعة تثبيت ما نحتاجه لبيئة البرمجة خاصتنا.

المرحلة الثالثة: تثبيت محرر النصوص nano (اختياري)

سنثبّت الآن nano، وهو محرر نصوص يستخدم واجهة سطر الأوامر، والذي يمكننا استخدامه لكتابة البرامج مباشرة داخل PowerShell. هذه ليست خطوة إلزامية، إذ يمكنك بدلاً من ذلك استخدام محرر نصوص بواجهة مستخدم رسومية مثل Notepad، لكن ميزة nano أنه سيُعوِّدك على استخدام PowerShell.

دعنا نستخدم Chocolatey لتثبيت nano:

choco install -y nano

الخيار ‎-y يعني أنَّك توافق على تنفيذ السكربت تلقائيًا دون الحاجة إلى تأكيد.

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

المرحلة الرابعة: تثبيت بايثون 3

مثلما فعلنا مع nano أعلاه، سنستخدم Chocolatey لتثبيت بايثون 3:

choco install -y python3

ستثبّت PowerShell الآن بايثون 3، مع عرض بعض المخرجات أثناء العملية. بعد اكتمال العملية، سترى المخرجات التالية:

Environment Vars (like PATH) have changed. Close/reopen your shell to
 See the changes (or in powershell/cmd.exe just type 'refreshenv').
The install of python3 was successful.
 Software installed as 'EXE', install location is likely default.

Chocolatey installed 1/1 packages. 0 packages failed.
 See the log for details (C:\ProgramData\chocolatey\logs\chocolatey.log).

بعد الانتهاء من التثبيت، ستحتاج إلى التحقق من أنّ بايثون مثبّتة وجاهزة للعمل. لرؤية التغييرات، استخدم الأمر refreshenv أو أغلق PowerShell ثم أعد فتحها بصلاحيات مدير النظام، ثم تحقق من إصدار بايثون على جهازك:

python -V

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

Python 3.7.0

سيتم تثبيت، إلى جانب بايثون، الأداة pip، وهي أداةٌ تعمل مع لغة بايثون تُثَبِّت وتدير الحزم البرمجية التي قد نحتاج إلى استخدامها في تطوير مشاريعنا. يمكنك تعلم المزيد عن الوحدات والحزم التي يمكنك تثبيتها بالأداة pip بقراءة المقالة كيفية استيراد الوحدات في بايثون 3 من هذه السلسلة.

سنحدّث pip عبر الأمر التالي:

python -m pip install --upgrade pip

يمكننا استدعاء بايثون من Chocolatey عبر الأمر python. سنستخدم الراية ‎-m لتنفيذ الوحدة كأنها سكربت، وإنهاء قائمة الخيارات، ومن ثمّ نستخدم pip لتثبيت الإصدار الأحدث.

بعد تثبيت بايثون وتحديث pip، فنحن جاهزون لإعداد بيئة افتراضية لمشاريع التطوير خاصتنا.

الخطوة الخامسة: إعداد بيئة افتراضية

الآن بعد تثبيت Chocolatey و nano وبايثون، يمكننا المضي قدمًا لإنشاء بيئة البرمجة خاصتنا عبر الوحدة venv.

تُمكِّنك البيئات الافتراضية من إنشاء مساحة معزولة في حاسوبك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه ستكون له اعتماديّاته (dependencies) الخاصة به، والتي لن تؤثِّر على غيره من المشاريع.

يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون، وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون. وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.

يمكنك ضبط أيّ عددٍ تشاء من البيئات الافتراضية، وكل بيئة ستكون ممثلة بمجلد في حاسوبك يحتوي على عدد من السكربتات.

اختر المجلد الذي تريد أن تضع فيه بيئات بايثون، أو يمكنك إنشاء مجلد جديد باستخدام الأمر mkdir كما يلي:

mkdir environments
cd environments

بعد أن انتقلتَ إلى المجلد الذي تريد احتواء البيئات فيه، تستطيع الآن إنشاء بيئة جديدة بتنفيذ الأمر التالي:

python -m venv my_env

باستخدام الأمر python، سننفّذ الوحدة venv لإنشاء البيئة الافتراضية التي أطلقنا عليها في هذه الحالة my_env.

ستنشئ venv مجلدًا جديدًا يحتوي على بعض العناصر التي يمكن عرضها باستخدام الأمر ls:

ls my_env

سنحصل على المخرجات التالية:

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----        8/22/2016   2:20 PM                Include
d-----        8/22/2016   2:20 PM                Lib
d-----        8/22/2016   2:20 PM                Scripts
-a----        8/22/2016   2:20 PM            107 pyvenv.cfg

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

عليك تفعيل البيئة لاستخدامها، وذلك بكتابة الأمر التالي الذي سيُنفِّذ سكربت التفعيل في المجلد Scripts:

my_env\Scripts\activate

يجب أن تظهر الآن سابقةٌ (prefix) في المِحث (prompt) والتي هي اسم البيئة المستخدمة، وفي حالتنا هذه يكون اسمها my_env.

(my_env) PS C:\Users\Sammy\Environments>

تتيح لنا هذه البادئة معرفة أنّ البيئة my_env مفعّلة حاليًا، وهذا يعني أننا لن سنستخدم إلا إعدادات وحزم هذه البيئة عند إنشاء مشاريع جديدة.

الخطوة الثالثة: إنشاء برنامج بسيط

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

علينا أولًا تشغيل المحرر nano وإنشاء ملف جديد:

(my_env) PS C:\Users\Sammy> nano hello.py

بعد فتح الملف في نافذة الطرفية، سنكتب البرنامج الخاص بنا:

print("مرحبا بالعالم!")

أغلق محرر nano بالضغط على Ctrl+x ثم اضغط على y عندما يسألك عن حفظ الملف.

بعد أن يُغلَق المحرر nano وتعود إلى سطر الأوامر، حاول تنفيذ البرنامج:

(my_env) PS C:\Users\Sammy> python hello.py

سيؤدي برنامج hello.py الذي أنشأتَه إلى طباعة الناتج التالي في الطرفية:

مرحبا بالعالم!

للخروج من البيئة، اكتب الأمر deactivate وستعود إلى مجلدك الأصلي.

الخلاصة

تهانينا! لقد ضبطتَ الآن بيئة تطويرٍ للغة بايثون 3 في نظام ويندوز 10، حان الآن الوقت للتعمق بلغة بايثون وإنشاء برامج رائعة! بالتوفيق.

ترجمة -وبتصرّف- للمقال How To Install Python 3 and Set Up a Local Programming Environment on windows 10 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيف تكتب أول برنامج لك
• المقالة السابقة: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

بايثون هي لغةٌ سهلة القراءة ومتنوعة ومتعددة الاستخدامات، وغالبًا ما تُستخدم في كتابة السكربتات (scripting) والأتمتة وتحليل البيانات وتعلم الآلة (machine learning) والتطوير الخلفي (back-end development).

ظهرت بايثون سنة 1991، واستوحي اسمها من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وبسيطة الإعداد، وجعل طريقة كتابتها مباشرة، مع توفير تقرير مباشر عند حدوث أخطاء. وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة. إصدار بايثون 3 هو الإصدار الحالي من اللغة ويُعدُّ مستقبل بايثون.

سيُرشِدُك هذا الدرس خطوةً بخطوة إلى كيفية تثبيت بايثون 3 على خادم أوبنتو 18.04، البرمجة على الخوادم لها العديد من الميزات، كما تدعم المشاريع التعاونية.

صحيحٌ أنَّ هذا الدرس يشرح عملية التثبيت على خادم أوبنتو 18.04، إلا أنَّ المفاهيم الأساسية فيه تنطبق على جميع توزيعات دبيان لينيكس (Debian Linux).

المتطلبات المسبقة

لمتابعة هذه المقالة، يجب أن تملك صلاحيات مستخدم غير جذري (non-root user ) مع امتيازات sudo على خادم أوبنتو 18.04. إذا لم تكن لك خبرة في التعامل مع بيئة النافذة الطرفية، فيمكنك مطالعة المقالة "مدخل إلى طرفيّة لينكس Linux Terminal".

الخطوة الأولى: إعداد بايثون 3

في أوبنتو 18.04 والإصدارات الأخرى من دبيان لينكس، ستجد كلًا من بايثون 3 وبايثون 2 مثبتين مسبقًا. للتأكد من أنّ إصدارات بايثون حديثة، سنحدّث النظام ونرقّيه باستخدام الأمر apt للعمل مع أداة التحزيم المتقدمة من أوبنتو (Ubuntu’s Advanced Packaging Tool):

sudo apt update
sudo apt -y upgrade

الخيار ‎-y يعني أنَّك توافق على تثبيت جميع الحزم القابلة للتحديث، لكن قد تحتاج إلى تأكيد ذلك عند تحديث النظام وذلك اعتمادًا على الحزم التي ستُحدَّث، ونسخة نظامك.

بعد إكمال العملية، يمكننا التحقق من إصدار بايثون 3 المُثبّت في النظام بكتابة:

python3 -V

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

Python 3.5.2

لإدارة الحزم البرمجية الخاصة ببايثون، سنثبّت pip، وهي أداةٌ تعمل مع لغة بايثون تُثَبِّت وتدير الحزم البرمجية التي قد نحتاج إلى استخدامها في تطوير مشاريعنا. يمكنك تعلم المزيد عن الوحدات والحزم التي يمكنك تثبيتها بالأداة pip بقراءة المقالة كيفية استيراد الوحدات في بايثون 3 من هذه السلسلة:

sudo apt install -y python3-pip

يمكن تثبيت حزم بايثون بكتابة ما يلي:

pip3 install package_name

حيث عليك وضع اسم الحزمة أو المكتبة التابعة لبايثون مكان package_name مثل Django لتطوير الويب، أو NumPy لإجراء الحسابات العلمية. لذا، إن شئتَ تنزيل NumPy فيمكنك تنفيذ الأمر pip3 install numpy.

هناك عدة حزم وأدوات تطوير أخرى يجب تثبيتها للتأكد من أنّ بيئة البرمجة جاهزة:

sudo apt install build-essential libssl-dev libffi-dev python3-dev

بعد أن انتهينا من ضبط بايثون وتثبيت pip، يمكننا الآن إنشاء «بيئة افتراضية» (virtual environment) لمشاريعنا.

الخطوة الثانية: إعداد بيئة افتراضية

تُمكِّنك البيئات الافتراضية من إنشاء مساحة معزولة في خادمك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه ستكون له اعتماديّاته (dependencies) الخاصة به، والتي لن تؤثِّر على غيره من المشاريع.

يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون، وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون. وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.

يمكنك ضبط أيُّ عددٍ تشاء من البيئات الافتراضية، وكل بيئة ستكون ممثلة بمجلد في خادمك يحتوي على عدد من السكربتات.

هناك عدة طرق لإعداد بيئة برمجية في بايثون، لكننا سنستخدم وحدة (module) برمجية باسم venv، وهي جزءٌ من مكتبة بايثون 3 القياسية. سنثبّت venv على نظامنا بكتابة:

sudo apt-get install -y python3-venv

بعد إتمام التثبيت، فنحن جاهزون لإنشاء البيئات الافتراضية، يمكننا الآن إما اختيار مجلد نضع فيه بيئات بايثون، أو إنشاء مجلد جديد باستخدام الأمر mkdir كما يلي:

mkdir environments
cd environments

بعد أن انتقلتَ إلى المجلد الذي تريد احتواء البيئات فيه، تستطيع الآن إنشاء بيئة جديدة بتنفيذ الأمر الآتي:

python3.6 -m venv my_env

سيُنشِئ الأمر pyvenv مجلدًا جديدًا فيه بعض الملفات التي يمكن عرضها باستخدام الأمر ls:

ls my_env

ستظهر لك مخرجات شبيهة بالمخرجات التالية:

bin include lib lib64 pyvenv.cfg share

تعمل هذه الملفات مع بعضها لضمان أنَ تكون مشاريعك معزولةٌ عن سياق الآلة المحلية، لكي لا تختلط ملفات النظام مع ملفات المشاريع. وهذا أمرٌ حسنٌ لإدارة الإصدارات ولضمان أنَّ كل مشروع يملك وصولًا إلى الحزمٍ التي يحتاجها. تتوافر أيضًا Python Wheels، والتي هي صيغة حزمٍ مبنية (built-package format) لبايثون، والتي يمكن أن تُسرِّع من تطوير البرامج بتقليل عدد المرات التي تحتاج فيها إلى تصريف (compile) المشروع، وهي موجودةٌ في المجلد share في توزيعة أوبنتو 18.04.

عليك تفعيل البيئة لاستخدامها، وذلك بكتابة الأمر التالي الذي سيُنفِّذ سكربت التفعيل:

source my_env/bin/activate

يجب أن تظهر الآن سابقةٌ (prefix) في المِحث (prompt) والتي هي اسم البيئة المستخدمة، وفي حالتنا هذه يكون اسمها my_env، وقد يكون مظهر المِحَث مختلفًا في توزيعة دبيان، وذلك اعتمادًا على الإصدار المستخدم؛ لكن يجب أن تشاهد اسم البيئة بين قوسين في بداية السطر:

(my_env) sammy@ubuntu:~/environments$

ستسمح لك السابقة بمعرفة أنَّ البيئة my_env مفعلة حاليًا، وهذا يعني أننا سنستخدم إعدادات وحزم هذه البيئة عند إنشاء مشاريع جديدة.

ملاحظة: يمكنك داخل البيئة الافتراضية أن تستخدم الأمر python بدلًا من python3 والأمر pip بدلًا من pip3 إن شئتَ. أما إذا كنتَ تستخدم بايثون 3 خارج البيئة الافتراضية، فيجب عليك حينها استخدام python3 و pip3 حصرًا.

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

الخطوة الثالثة: إنشاء برنامج بسيط

بعد أن أكملنا ضبط بيئتنا الافتراضية، لننشِئ برنامجًا بسيطًا يعرض العبارة «Hello World!‎»، وبهذا سنتحقق من أنَّ البيئة تعمل بالشكل الصحيح، ولكي تتعوّد على إنشاء برامج بايثون إن كنتَ وافدًا جديدًا على اللغة.

علينا أولًا تشغيل محرر ملفات نصية لإنشاء ملف جديد، وليكن المحرر nano الذي يعمل من سطر الأوامر:

(my_env) sammy@ubuntu:~/environments$ nano hello.py

بعد فتح الملف في نافذة الطرفية، سنكتب البرنامج الخاص بنا:

print("Hello, World!")

أغلق محرر nano بالضغط على Ctrl+x ثم اضغط على y عندما يسألك عن حفظ الملف.

بعد أن يُغلَق المحرر nano وتعود إلى سطر الأوامر، حاول تنفيذ البرنامج:

(my_env) sammy@ubuntu:~/environments$ python hello.py

سيؤدي برنامج hello.py الذي أنشأتَه إلى طباعة الناتج الآتي في الطرفية:

Hello, World!

للخروج من البيئة، اكتب الأمر deactivate وستعود إلى مجلدك الأصلي.

الخلاصة

تهانينا! لقد ضبطتَ الآن بيئة تطويرٍ للغة بايثون 3 في خادم لينيكس ديبيان، حان الآن الوقت للتعمق بلغة بايثون وإنشاء برامج رائعة! بالتوفيق.

ترجمة -وبتصرّف- للمقال How To Install Python 3 and Set Up a Programming Environment on an Ubuntu 18.04 Server لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيف تكتب أول برنامج لك
• المقالة السابقة: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

Python هي لغةٌ سهلة القراءة للغاية ومتنوعة ومتعددة الاستخدامات، واسمها مستوحى من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وإعدادها بسيطٌ، وطريقة كتابتها مباشرة وتعطيك تقريرًا مباشرًا عند حدوث أخطاء، وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة.
لغة بايثون هي لغة متعددة الاستعمالات، وتدعم مختلف أنماط البرمجة مثل كتابة السكربتات والبرمجة كائنية التوجه (object-oriented)، وهي مناسبةٌ للأغراض العامة، واستعمالها يتزايد في سوق العمل إذ تعتمدها منظماتٌ مثل «United Space Alliance» (شركة في مجال إرسال مركبات فضائية وتتعاقد معها ناسا) و «Industrial Light & Magic» (أستوديو للتأثيرات السينمائية وللرسوم المتحركة)، وتوفِّر بايثون قدراتٍ كثيرةٍ لمن يريد تعلم لغة برمجة جديدة.
طوِّرَت اللغة في نهاية الثمانينات من القرن الماضي، ونُشِرَت أوّل مرة في عام 1991، طُوِّرَت بايثون من قِبل Guido van Rossum، وهو عضوٌ نشطٌ للغاية في المجتمع. وتعتبر بايثون على أنَّها بديلٌ عن لغة ABC، وأوّل إصدار منها كان يتضمن التعامل مع الاستثناءات (exception handling) والدوال والأصناف (classes) مع إمكانية الوراثة فيها. وعدما أُنشِئ منتدى محادثة في Usenet باسم comp.lang.python في 1994، فبدأت قاعدة مستخدمي بايثون بالنمو، مما مهّد الطريق لها لتصبح واحدة من أكثر لغات البرمجة شيوعًا وخصوصًا لتطوير البرمجيات مفتوحة المصدر.

لمحة عامة

قبل أن ننظر إلى إمكانيات إصدارَي بايثون 2 وبايثون 3 (مع الاختلافات البرمجية الرئيسية بينهما)، فلننظر إلى لمحة تاريخية عن الإصدارات الرئيسية الحديثة من بايثون.

بايثون 2

نُشِرَ هذا الإصدار في أواخر عام 2000، وأصبحت بايثون 2 لغة برمجة شاملة مقارنةً بالإصدارات التي تسبقها وذلك بعد تطبيق اقتراح PEP ‏(Python Enhancement Proposal)، وهو مواصفةٌ (specification) تقنيةٌ التي توفِّر معلومات إلى أعضاء مجتمع بايثون أو تصف ميزاتٍ جديدة في اللغة.
بالإضافة إلى ذلك، تضمنت بايثون 2 ميزاتٍ برمجية جديدة مثل «cycle-detecting garbage collector» لأتمتة عملية إدارة الذاكرة، وزيادة دعم يونيكود لتدعم اللغة جميع المحارف المعيارية …إلخ. وأثناء عملية تطوير بايثون 2 أضيفت ميزات جديدة بما في ذلك توحيد الأنواع والأصناف في بايثون في بنية هيكلية وحيدة (وذلك في إصدار 2.2 من بايثون).

بايثون 3

تُعتَبر بايثون 3 هي مستقبل لغة بايثون وهي النسخة قيد التطوير من اللغة، وهذا إصدارٌ رئيسيٌ نُشِر في أواخر عام 2008 لإصلاح بعض المشاكل الجوهرية في تصميم الإصدارات السابقة من اللغة، وكان التركيز أثناء تطوير بايثون 3 هو تحسين الشيفرات التي تبنى عليها اللغة وحذف التكرارات، مما يعني أنَّ هنالك طريقة وحيدة فقط لإنجاز مهمّة معيّنة.
التعديلات الأساسية التي حدثت في بايثون 3.0 تتضمن تغير العبارة print إلى دالة مُضمَّنة باللغة، وتحسين قسمة الأعداد الصحيحة، وتوفير دعم إضافي ليونيكود.
في البداية، انتشرت بايثون 3 ببطء نتيجةً لعدم توافقيتها مع بايثون 2، مما يعني أنَّ على المستخدمين اختيار ما هو الإصدار الذي عليهم استخدامه. بالإضافة إلى ذلك، كانت الكثير من المكتبات البرمجية متاحةً فقط لبايثون 2، لكن بعد تقرير فريق تطوير بايثون 3 أنَّه يجب أن التخلي عن دعم بايثون 2، فبدأت عملية تحويل المكتبات إلى بايثون 3. يمكننا معرفة زيادة الاعتماد على بايثون 3 من خلال عدد الحزم البرمجية التي تدعم بايثون 3، والتي هي (في وقت كتابة هذا المقال) 339 من أصل 360 من أشهر الحزم.

بايثون 2.7

بعد إصدار بايثون 3.0 في 2008، أُصدِرَت نسخة بايثون 2.7 في تموز 2010 وهي آخر إصدار من سلسلة ‎2.x، الغرض من إصدار بايثون 2.7 هو جعل الطريق ممهدًا أمام مستخدمي بايثون ‎2.x لتحويل برامجهم إلى بايثون 3 بتوفير بعض التوافقية بينهما. وهذه التوافقية تضمنت دعم بعض الوحدات المُحسّنة في 2.7 مثل unittest لأتمتة الاختبارات، و argparse لتفسير خيارات سطر الأوامر، وبعض الفئات في collections.
ولخصوصية بايثون 2.7 ولكونها جسرًا واصلًا بين الإصدارات القديمة من بايثون 2 وبين بايثون 3.0، فأصبحت خيارًا شائعًا بين المبرمجين بسبب توافقيتها مع الكثير من المكتبات.
عندما نتحدث اليوم عن بايثون 2، فنحن نشير عادةً إلى إصدار بايثون 2.7 لأنَّه أكثر إصدار مستخدم؛ لكنه يُعتَبَر أنَّه إصدارٌ قديم، وسيتوقف تطويره (التطوير الحالي هو إصلاح العلل فقط) تمامًا في 2020.

الاختلافات الأساسية

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

print

في بايثون 2، تُعامَل print كتعبيرٍ برمجيٍ بدلًا من كونها دالة، وهذا كان يثير ارتباكًا لأنَّ الكثير من الأمور داخل بايثون تتطلب تمرير وسائط (arguments) بين قوسين، إذا فتحتَ مُفسِّر بايثون 2 لطباعة «Sammy the Shark is my favorite sea creature»، فستكتب تعبير print الآتي:

print "Sammy the Shark is my favorite sea creature"

أما في بايثون 3، فستُعامَل print()‎ كدالة، لذا لطباعة السلسلة النصية السابقة، فيمكننا استخدام شكل استدعاء الدوال التقليدي كما يلي:

print("Sammy the Shark is my favorite sea creature")

هذا التعديل جعل من البنية اللغوية في بايثون موحدةً وسهَّلَ من التبديل بين مختلف دوال الطباعة فيها. يجدر بالذكر أنَّ الدالة print()‎ متوافقة مع بايثون 2.7، لذا ستعمل شيفرات بايثون التي تستعمل print()‎ بشكلٍ صحيحٍ في أيّ الإصدارَين.

قسمة الأعداد الصحيحة

في بايثون 2، أيُّ عددٍ تكتبه دون فواصل عشرية سيُعامَل على أنَّه من النوع integer، تأتي الإشكالية عندما تحاول قسمة الأعداد الصحيحة على بعضها، فتتوقع في بعض الأحيان حصولك على عددٍ عشري (تسمى أيضًا بالأعداد ذات الفاصلة العائمة float) كما في التعبير الرياضي:

5 / 2 = 2.5

لكن الأعداد الصحيحة في بايثون 2 لن تتحول إلى أعداد عشرية عندما تتطلب العملية التي تُجرى عليها ذلك.
عندما يكون العددان الموجودان على جانبَي معامل القسمة / عددين صحيحين، فإن بايثون 2 ستجري عملية القسم وستُنتِج عددًا عشريًا إلا أنها ستُعيد العدد الصحيح الأصغر أو المساوي للناتج، وهذا يعني أنَّه لو كتبتَ ‎5 / 2 فستُعيد بايثون 2.7 العدد الصحيح الأصغر أو المساوي للعدد 2.5، وهو في هذه الحالة 2:

a = 5 / 2
print a

2

لإعادة عدد عشري، فيجب إضافة فواصل عشرية إلى الأرقام التي ستُجري عليها عملية القسمة كما في ‎5.0 / 2.0 لكي تحصل على النتيجة المنطقية 2.5.
أما في بايثون 3، فقسمة الأعداد الصحيحة أصبحت كما نتوقع:

a = 5 / 2
print a

2.5

يمكنك استخدام ‎5.0 / 2.0 لإعادة 2.5، لكن إن أردتَ تقريب ناتج القسمة فاستخدم المعامل // الموجود في بايثون 3، كالآتي:

a = 5 // 2
print a

2

هذا التعديل في بايثون 3 جعل من قسمة الأعداد الصحيحة أمرًا سهلًا، لكن هذه الميزة غير متوافقة مع بايثون 2.7.

دعم محارف يونيكود

عندما تتعامل لغات البرمجة مع السلاسل النصية (strings، والتي هي سلسلةٌ من المحارف)، فهي تفعل ذلك بطرائق مختلفة لكي تتمكن الحواسيب من تحويل الأعداد إلى أحرف ورموز.
تستعمل بايثون 2 محارف ASCII افتراضيًا، لذا عندما تكتب "Hello, Sammy!‎" فستتعامل بايثون 2 مع السلسلة النصية كمجموعة من محارف ASCII، والتي هي محدودةٌ لحوالي مئتَي محرف، أي أنَّ محارف ASCII هي طريقة غير عملية لترميز المحارف خصوصًا المحارف غير اللاتينية (كالعربية مثلًا).
لاستخدام ترميز محارف يونيكود (Unicode) الذي يدعم أكثر من 128000 محرف تابع للكثير من اللغات والرموز، فعليك أن تكتب u"Hello, Sammy!‎"‎ حيث تُشير السابقة u إلى Unicode.
تستعمل بايثون 3 محارف يونيكود (Unicode) افتراضيًا، مما يوفِّر عليك بعض الوقت أثناء التطوير، ويمكنك كتابة وعرض عدد أكبر بكثير من المحارف في برنامجك بسهولة. يدعم يونيكود الكثير من المحارف بما في ذلك الوجوه التعبيرية (emojis)، واستعمالها كترميز محارف افتراضي يعني أنَّ الأجهزة المحمولة ستكون مدعومةً في مشاريعك تلقائيًا.
إذا كنت تحب أنَّ تكون شيفرات بايثون 3 التي تكتبها متوافقةً مع بايثون 2، فأبقِ على حرف u قبل السلاسل النصية.

استمرار التطوير

الفارق الرئيسي بين بايثون 3 وبايثون 2 ليس في البنية اللغوية وإنما في أنَّ إصدار بايثون 2.7 سيتوقف دعمه في 2020، وسيستمر تطوير بايثون 3 بميزاتٍ جديدة وإصلاحٍ لمزيدٍ من العلل.
التطويرات الأخيرة في اللغة تتضمن تخصيصًا أبسط لإنشاء الأصناف، وطريقةً أوضح للتعامل مع المصفوفات…
الاستمرار بتطوير بايثون 3 يعني أنَّ المطورين يمكن أن يعتمدوا على اللغة، وسيطمئنون أنَّ المشاكل التي قد تحدث فيها ستُحَل في فترةٍ قريبة، ويمكن أن تصبح البرامج أكثر كفاءة بإضافة المزيد من الميزات للغة.

نقاط أخرى يجب أخذها بالحسبان

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

إذا كنتَ تأمل بتعلم اللغة دون أن تفكِّر بمشروعٍ معيّن، فأنصحك بالتفكير بمستقبل بايثون، فسيستمر تطوير ودعم بايثون 3 بينما سيوقف دعم بايثون 2.7 عمّا قريب.
أما إذا كنتَ تُخطِّط للانضمام لفريق تطوير أحد المشاريع، فعليك أن تنظر ما هو إصدار بايثون المستخدم فيه، وكيف يؤدي اختلاف الإصدار إلى اختلاف طريقة تعاملك مع الشيفرات، وإذا ما كانت المكتبات البرمجية المستعملة في المشروع مدعومةً في مختلف الإصدارات، وما هي تفاصيل المشروع نفسه…
إذا كنت تُفكّر ببدء أحد المشاريع، فيجدر بك أن تنظر ما هي المكتبات المتوفرة وما هي إصدارات بايثون المدعومة. وكما قلنا سابقًا، الإصدارات الأوليّة من بايثون 3 لها توافقية أقل مع المكتبات المبنية لبايثون 2، لكن الكثير منها قد جرى تحويله إلى بايثون 3، وسيستمر ذلك في السنوات الأربع المقبلة.

الخلاصة

لغة بايثون كبيرة جدًا وموثقة توثيقًا ممتازًا وسهلة التعلم، ومهما كان اختيارك (بايثون 2 أو بايثون 3) فستتمكن من العمل على المشاريع الموجودة حاليًا.
صحيحٌ أنّ هنالك بعض الاختلافات المحورية، لكن ليس من الصعب الانتقال من بايثون 3 إلى بايثون 2، وستجد عادةً أنَّ بايثون 2.7 قادرة على تشغيل شيفرات بايثون 3، خصوصًا في بدايات تعلمك للغة.
من المهم أن تبقي ببالك أنَّ تركيز المطورين والمجتمع أصبح منصبًّا على بايثون 3، وسيصبح هذه اللغة رائدةً في المستقبل وستلبي الاحتياجات البرمجية المطلوبة، وأنَّ دعم بايثون 2.7 سيقل مع مرور الزمن إلى أن يزول في 2020.
ترجمة -وبتصرّف- للمقال Python 2 vs Python 3: Practical Considerations لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: تثبيت بايثون على مختلف أنظمة التشغيل وإعداد بيئتها البرمجية
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون
• مميزات لغة بايثون

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

الخطأ الأول: استخدام أنواع البيانات القابلة للتغير كوسائط افتراضية عند تعريف الدالة

لنقل أنَّ لديك دالة صغيرة التي تبحث عن روابط في الصفحة الحالية وتستطيع إضافتها إلى قائمة (list) معيّنة.

def search_for_links(page, add_to=[]):
    new_links = page.search_for_links()
    add_to.extend(new_links)
    return add_to

لا يبدو أنَّ هنالك أيّ خطأ في الدالة السابقة، وهذا صحيح، فهي تعمل لكن هنالك مشاكل فيها؛ فلو مررنا قائمةً (list) إلى المعامل add_to فستعمل كما يجب، لكن ماذا يحدث لو تركنا القيمة الافتراضية دون تعديل؟
جرِّب تنفيذ الشيفرة الآتية:

def fn(var1, var2=[]):
    var2.append(var1)
    print var2

fn(3)
fn(4)
fn(5)

ستتوقع رؤية الناتج الآتي:

[3]
[4]
[5]

لكنك ستُفاجأ بالناتج الآتي:

[3]
[3, 4]
[3, 4, 5]

لماذا؟! يمكنك أن تستنتج أن القائمة (list) نفسها ستستعمل في كل مرة، فعندما نكتب دالة مثل الدالة السابقة في بايثون فسيتم تهيئة القائمة (list) كجزءٍ من تعريف الدالة، أي أنها لن تُهيّئ كل مرة تُستدعى فيها الدالة، وهذا يعني أنَّ الدالة ستحتفظ بكائن القائمة نفسه مرارًا وتكرارًا، ما لم تُحدِّد قيمةً أخرى له:

fn(3, [4])

الناتج:

[4, 3]

الناتج يماثل ما قد توقعناه.
الطريقة الصحيحة لفعل ذلك هي:

def fn(var1, var2=None):
    if not var2:
        var2 = []
    var2.append(var1)

لنعد كتابة الدالة السابقة:

def search_for_links(page, add_to=None):
    if not add_to:
        add_to = []
    new_links = page.search_for_links()
    add_to.extend(new_links)
    return add_to

نقلنا عملية التهيئة من مكان تعريف الدالة إلى داخلها مما يعني أنَّ عملية التهيئة ستتم في كل مرة تُشغَّل فيها الدالة.
لاحظ أنَّ ذلك ليس ضروريًا إذا كنتَ تستعمل أنواع بيانات غير قابلة للتعديل مثل tuple أو string أو int. وهذا يعني أنَّك تستطيع تعريف دالة كما في الدالة الآتية دون إمكانية حدوث أخطاء غير متوقعة:

def func(message="my message"):
    print message

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

هذا الخطأ شبيهٌ كثيرًا بالخطأ السابق. تمعّن في الشيفرة الآتية:

class URLCatcher(object):
    urls = []

    def add_url(self, url):
        self.urls.append(url)

الشيفرة السابقة تبدو طبيعية جدًا، فلدينا كائن لتخزين روابط URL، وعند استدعائنا للدالة add_url فسنمرر إليها رابط URL لتخزِّنه، صحيح؟ لنجرِّبها:

a = URLCatcher()
a.add_url('http://www.google.')
b = URLCatcher()
b.add_url('http://www.bbc.co.')

الناتج:

b.urls
['http://www.google.com', 'http://www.bbc.co.uk']

a.urls
['http://www.google.com', 'http://www.bbc.co.uk']

ما هذا؟! لم نتوقع ذلك. إذ أنشأنا كائنين منفصلين a و b، وأسندنا رابطًا للكائن a مختلفًا عن رابط الكائن b، فكيف امتلك كلا الكائنين الرابطين نفسهما؟
اتضح أنَّ هذه المشكلة شبيهة جدًا بالمشكلة في المثال الأول، فقائمة (list) عناوين URL قد تمت تهيئتها عند تعريف الصنف (class)، وبالتالي أمست جميع الكائنات المُنشَأة من ذاك الصنف تستعمل القائمة نفسها.
هنالك بعض الحالات التي نستفيد فيها من هذه الميزة، لكنها ستضرك في أغلبية الأوقات، فلو أردتَ تخزين بيانات كل كائن على حدة فيمكنك تعديل الشيفرة لتصبح كما يلي:

class URLCatcher(object):
    def __init__(self):
        self.urls = []

    def add_url(self, url):
        self.urls.append(url)

أصبحت قائمة urls تُهيّئ عند إنشاء الكائن، وعندما نُنشِئ كائنين فستُهيّئ قائمتان منفصلتان.

الخطأ الثالث: عملية إسناد قيم إلى نوع بيانات قابل للتعديل

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

a = {'1': "one", '2': 'two'}

لنفترض أننا نريد أخذ قيمة المتغير a واستعمالها في مكانٍ آخر دون تعديل القيمة الأصلية:

b = a

b['3'] = 'three'

أليس هذا بسيطًا؟ لننظر الآن إلى القيمة المخزّنة في المتغير a التي لم نُعدِّلها قط:

{'1': "one", '2': 'two', '3': 'three'}

ماذا؟! كيف ستبدو قيمة المتغير b إذًا؟

{'1': "one", '2': 'two', '3': 'three'}

دعنا نعود خطوةً إلى الوراء وننظر ماذا يحدث لو استعملنا أنواع البيانات غير القابلة للتعديل، مثل tuple:

c = (2, 3)
d = c
d = (4, 5)

قيمة c هي:

(2, 3)

بينما قيمة d هي:

(4, 5)

لقد جرى كل شيءٍ على ما يرام، لذا ماذا حدث في مثالنا؟ عند استخدام أنواع البيانات القابلة للتعديل فسنحصل على شيءٍ شبيهٍ بالمؤشرات (pointers) في لغة C، فعندما قلنا أنَّ b = a في الشيفرة السابقة فهذا يعني أنَّ المتغير b أصبح يُشير إلى a، وكلا المتغيرين يشير إلى نفس الكائن في ذاكرة بايثون؟ هل هذا مألوف لديك؟ ذلك لأن هذه المشكلة شبيهة بالمشاكل السابقة، وكنتُ أنوي تسمية هذا الدرس باسم «المشاكل التي تحدث مع أنواع البيانات القابلة للتعديل».
هل يحدث الأمر نفسه مع القوائم (list)؟ نعم. وكيف سنلتف على المشكلة؟ حسنًا، يجب أن نكتب الشيفرة الآتية التي تنسخ القائمة:

b = a[:]

السطر السابق سيؤدي إلى نسخ مرجعية كل عنصر من عناصر القائمة ووضعه في قائمة جديدة، لكن لنأخذ حِذرنا فإذا كان نوع بيانات أحد الكائنات الموجودة في القائمة قابلًا للتعديل فسيؤدي ذلك إلى الحصول إلى مرجعية لتلك الكائنات بدلًا من نسخها.
تخيل وجود قائمة على قطعة من الورق، ففي المثال الأصلي كان ينظر الشخص A والشخص B إلى الورقة نفسها، فلو عدّل شخصٌ ما القائمةَ فسيرى كلا الشخصين التعديلات التي أجريت على القائمة، وعندما نسخنا المرجعيات فأصبح لكل شخصٍ قائمته الخاصة به، لكن لنفترض أنَّ تلك القائمة تحتوي على أماكن يمكن البحث فيها عن طعام، فلو كانت «الثلاجة» موجودة في القائمة فحتى لو نسخها الشخص A و B فما تزال تشير إلى الثلاجة نفسها؛ فلو أتى الشخص A وعدّل محتويات الثلاثة (لنفترض أنه أكل جميع الحلويات فيها) فسيلاحظ الشخص B أن الحلويات قد اختفت من الثلاثة. ولا توجد طريقة سهلة للالتفاف على هذه المشكلة، وهذا أمرٌ مهمٌ عليك تذكره عندما تبرمج لكي تكتب شيفرتك بطريقة لا تسبِّب أيّة مشاكل.
تعمل أنواع dict بنفس الطريقة، ويمكنك إنشاء نسخة كاملة باستعمال الدالة copy()‎:

b = a.copy()

أكرِّر أنَّ ذلك سيُنشِئ متغيرًا جديدًا من نوع dict يُشير إلى نفس العناصر الموجودة في المتغير الأصلي، وبالتالي لو كان لدينا قائمتان متماثلتين وعدّلنا كائنًا قابلًا للتعديل مُشار إليه عبر مفتاح موجود في المتغير a فيمكن معرفة تلك التعديلات من داخل المتغير b.
الإشكاليات التي تواجهنا مع أنواع البيانات القابلة للتعديل تكون نتيجةً لمرونة تلك الأنواع، حيث لا تُشكِّل أيٌّ مما سبق مشكلةً حقيقة، وإنما هي أمور ضرورية يجب أخذها بالحسبان لتنجب المشاكل. وعمليات النسخ الكاملة التي ذكرناها آنفًا لن تكون ضروريةً في 99% من الحالات، أي يجب تعديل برنامجك لكي لا يحتاج إلى استخدام تلك النسخ من الأساس.
ترجمة –وبتصرّف– للمقال ‎3 mistakes to avoid when learning to code in Python لصاحبه Pete Savage

تساعدك الواجهة البرمجية (API) الخاصة بموقع التواصل الاجتماعي تويتر في إدارة الحسابات الموجودة فيه، كما وتسمح لك بالتنقيب عما يحتويه من بيانات. هذا الأمر يفيدك – مثلاً - في عملية ترويج هوية المؤسسة أو المنظمة التي تعمل فيها، وكذلك يُعدّ ممتعًا ومسليًا للمستخدمين الأفراد وهواة البرمجة.
في هذا الدرس سوف نشرح لكم الخطوات اللازمة لإنشاء تطبيق توتير، وبعد ذلك سنبني سكربت بايثون من خلال استخدام مكتبة Tweepy للاستفادة من التطبيق و نشر تغريدات من خلاله.

المتطلبات

قبل البدء، تأكد من وجود المتطلبات التالية:

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

الخطوة الأولى: إنشاء تطبيق تويتر

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

سوف تُوجَّه إلى صفحة بناء التطبيق التالية:

أدخل في هذه الصفحة الحقول المطلوبة كما في المثال التالي:

الاسم: AcademyHsoubTest
الوصف: Academy Hsoub Application
الموقع: https://my.example.placeholder

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

ستُوجَّه بعد أن نجاح إنشاء التطبيق إلى صفحة التطبيق التالية، والتي تُقدم لك بعض المعلومات العامة عن التطبيق.

الخطوة الثانية: تعديل مستوى الإذن للتطبيق وتوليد رموز الوصول الخاصة به

من صفحة التفاصيل (Details Page) السابقة، اذهب لخيار الأذونات (Permissions) وذلك للتأكد من أننا نمتلك مستوى الوصول المطلوب لتوليد مفاتيح التطبيق.

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

اذهب بعد التأكد من أذونات التطبيق التي تسمح له بالنشر إلى خيار المفاتيح ورموز الوصول (Keys and Access Tokens). ستُنقَل إلى صفحة تعرض لك مفتاح المستهلك (Consumer Key) والرمز السري للمستهلك (Consumer Secret)، وكذلك تُمكنك من توليد رمز الوصول ورمز الوصول السري. هذه الرموز والمفاتيح هي التي ستقوم بعملية الاستيثاق لتطبيقك مع تويتر.

اضغط على الزر المعنون ب (Create my access token) لتوليد رمز الوصول ورمز الوصول السري.

أصبح لديك الآن رمز الوصول ورمز الوصول السري.

الخطوة الثالثة: تثبيت مكتبة Tweepy

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

مكتبة Tweepy مفتوحة المصدر وسهلة الاستخدام وتسمح للمشاريع المكتوبة بلغة البايثون بالوصول للواجهة البرمجية لتويتر بكل سهولة.

سنستخدم أداة pip لتثبيت مكتبة tweepy.

أنشئ مجلدًا خاصًّا للمشروع باسم twitter.

تأكد قبل تثبيت المكتبة أن أداة pip مُحدثة:

>> pip install --upgrade pip

بعد أن تُحدَّث الأداة بنجاح، نثبّت مكتبة Tweepy:

>> pip install tweepy

بعد تثبيت المكتبة تستطيع البدء بكتابة البرنامج.

الخطوة الرابعة: بناء البرنامج الذي يتخاطب مع الواجهة البرمجية لتويتر

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

أنشئ باستخدام محرر النصوص المفضل لديك ملف بايثون باسم helloworld.py في داخل المجلد twitter الذي أنشأناه في الخطوة السابقة.
في بداية الملف، نحتاج أن نستورد المكتبة باستخدام جملة import:

import tweepy

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

import tweepy

consumer_key = 'your_consumer_key'
consumer_secret = 'your_consumer_secret'
access_token = 'your_access_token'
access_token_secret = 'your_access_token_secret'

ننشئ بعدها عنصرًا من الصنف OAuthHandler الموجود في مكتبة Tweepy وسنمرر لهذا العنصر المفاتيح والرموز الموجودة لدينا. يعمل هذا العنصر من خلال بروتوكول HTTP يعطي التصريح اللازم للأجهزة، الواجهات البرمجية، الخوادم والتطبيقات، ويعدّ هذا الصنف صنفا معياريا يقدّم ألية وصول آمن وذي تفويض كامل.
نعدّ كذلك رموز الوصول وندمجها مع الواجهة البرمجية المنشأة من تعريف عنصر من نوع API.

import tweepy

consumer_key = 'your_consumer_key'
consumer_secret = 'your_consumer_secret'
access_token = 'your_access_token'
access_token_secret = 'your_access_token_secret'

auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

نحدّد في نهاية البرنامج النص الذي سننشره. عرف متغيرًا باسم tweet ومرر له النص الذي تريد نشره ومرّر هذا المتغير للدالة api.update_status.

import tweepy

# Create variables for each key, secret, token
consumer_key = 'your_consumer_key'
consumer_secret = 'your_consumer_secret'
access_token = 'your_access_token'
access_token_secret = 'your_access_token_secret'

# Set up OAuth and integrate with API
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

# Write a tweet to push to our Twitter account
tweet = 'أكاديمية حسوب، أهلا بالعالم'
api.update_status(status=tweet)

تستطيع الان حفظ الملف وتشغيله:

>> python helloworld.py

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

نشرت التغريدة على الخط الزمني لحسابك بنجاح وبذلك تكون قد هيّأت تطبيق تويتر واستخدمته من خلال مكتبة Tweepy!

خاتمة

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

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

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

ترجمة - بتصرّف - للمقال How To Create a Twitter App لصاحبته Lisa Tagliaferri.

حقوق الصورة البارزة محفوظة لـ Freepik

في بدايات التسعينات، قام Guido van Rossum بإنشاء لغة البايثون. تُعتبر البايثون من أشهر لغات البرمجة حاليا، ولها حضور واسع في العديد من المجالات التطبيقية والعلمية، وتتميز بسهولة شفرتها البرمجية وسرعة تعلمها مع متانة وقوة تضاهي اللغات الأخرى.
سوف نتناول في هذا المقال المواضيع التالية:

1. التعليقات.
2. أنواع البيانات.
3. المتغيرات والتراكيب.
4. جمل التحكم.
5. الدوال Functions.
6. الوحدات.
7.  الفئات.

ملاحظة: إصدار البايثون 3 هو المعتمد في شرح هذا المقال، وناتج العمليات والأوامر في هذا المقال سيتم كتابتها بعد الرمز # =>.

التعليقات

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

# Single line comments start with a number symbol.

""" Multiline strings can be written
    using three "s, and are often used
    as documentation.
"""

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

أنواع البيانات والعمليات

الأرقام:

3  # => 3

العمليات الرياضية:

1 + 1   # => 2
8 - 1   # => 7
10 * 2  # => 20
35 / 5  # => 7.0

يوجد نوعان من القسمة في بايثون 3، الأولى تُسمى القسمة بعدد فاصل عائم “floating point division” ونَستخدم رمز القسمة المعروف / ، وناتج العملية هو دائما عدد حقيقي من النوع float:

10.0 / 3  # => 3.3333333333333335

أما النوع الثاني من القسمة فيُسمى القسمة الصحيحة “integer division” ونَستخدم الرمز // لهذا النوع، ويكون ناتج العملية دون الفاصلة والأرقام التي بعدها:

5 // 3       # => 1
5.0 // 3.0   # => 1.0 # يعمل هذا النوع من القسمة على الأعداد الحقيقية أيضا
-5 // 3      # => -2
-5.0 // 3.0  # => -2.0

عملية باقي القسمة:

7 % 3  # => 1

عملية الأس:

2**3  # => 8

قاعدة أولوية العمليات حسب الأقواس:

(1 + 3) * 2  # => 8

القيم المنطقية (لاحظ الحرف الكبير في البداية):

True
False

عكس القيمة المنطقية باستخدام not:

not True   # => False
not False  # => True

العمليات المنطقية (العمليات المنطقية حساسة لحالة الأحرف):

True and False  # => False
False or True   # => True

القيمة المنطقية False تساوي الرقم 0، والقيمة المنطقية True تساوي الرقم 1:

0 and 2     # => 0
-5 or 0     # => -5
0 == False  # => True
2 == True   # => False
1 == True   # => True
-5 != False != True #=> True

عملية فحص المساواة باستخدام ==:

1 == 1  # => True
2 == 1  # => False

فحص عدم المساواة:

1 != 1  # => False
2 != 1  # => True

المقارنات:

1 < 10  # => True
1 > 10  # => False
2 <= 2  # => True
2 >= 2  # => True
1 < 2 < 3  # => True
2 < 3 < 2  # => False

تفحص عملية is إذا كان متغيران يشيران لنفس الكائن أم لا، ولكن العملية == تفحص إذا كانا بنفس القيمة أم لا:

a = [1, 2, 3, 4]  
b = a             
b is a            # => True
b == a            # => True
b = [1, 2, 3, 4]  
b is a            # => False
b == a            # => True

تُنشَأ النصوص باستخدام علامات التنصيص المزدوجة أو الفردية:

"This is a string."
'This is also a string.'

تستطيع جمع النصوص ببعضها، ولكن حاول تجنب هذه الطريقة:

"Hello " + "world!"  # => "Hello world!"

تستطيع دمج النصوص ببعضها دون استخدام + :

"Hello " "world!"    # => "Hello world!"

من الممكن التعامل مع النص وكأنه مصفوفة من الحروف:

"This is a string"[0]  # => 'T'

للحصول على طول نص نستخدم الدالة المضمنة len :

len("This is a string")  # => 16

تستطيع استخدام الدالة format لإجراء عملية التنسيق على النص:

"{} can be {}".format("Strings", "interpolated")  # => "Strings can be interpolated"

تستطيع عند استخدام الدالة format ترقيم المدخلات حسب ترتيبها واستخدامها في تنسيق النص أكثر من مرة:

"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"

أو باستخدام طريقة تسمية المدخلات:

"{name} wants to eat {food}".format(name="Bob", food="lasagna")  # => "Bob wants to eat lasagna"

تستطيع في البايثون 3 استخدام الطريقة القديمة في بايثون 2 لعمل تنسيق للنصوص:

"%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"

None عبارة عن كائن:

None  # => None

لا تستخدم فحص المساواة باستخدام رمز == للمقارنة مع None واستخدم عملية الفحص is بدلا منها:

"etc" is None  # => False
None is None   # => True

None والرقم 0 والمتغيرات الفارغة من الأنواع strings، lists، dict، وtuples جميعها تُرادف القيمة المنطقية False، أما باقي القيم فهي True:

# All other values are True
bool(0)   # => False
bool("")  # => False
bool([])  # => False
bool({})  # => False
bool(())  # => False

المتغيرات والتراكيب:

تتوفّردالة خاصة للطباعة (الإخراج على الطرفية) وتسمى print:

print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!

يُطبَع سطر جديد تلقائيا عند استخدام الدالة print. تستطيع استخدام المعطى end لتغيير هذا الأمر وتحديد النص الذي تريده بدلا من السطر الجديد:

print("Hello, World", end="!")  # => Hello, World!

للحصول على مدخلات من الطرفية نستخدم الدالة input:

input_string_var = input("Enter some data: ") # Returns the data as a string

ملاحظة/ في النسخ القديمة من البايثون، كانت الدالة input باسم raw_input.

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

some_var = 5
some_var  # => 5

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

some_unknown_var  # ينتُج خطأ من الصنف NameError

تشبه القوائم المصفوفات في اللغات الأخرى:

li = []
other_li = [4, 5, 6]

نستخدم append لإضافة عناصر في نهاية القائمة:

li.append(1)    # li is now [1]
li.append(2)    # li is now [1, 2]
li.append(4)    # li is now [1, 2, 4]
li.append(3)    # li is now [1, 2, 4, 3]

نستخدم الدالةpop لحذف العناصر من آخر القائمة. ترجع التعليمة أدناه القيمة 3 وتصبح مكونات القائمة [1, 2, 4]:

li.pop()        # => 3 and li is now [1, 2, 4]

تعود القائمة إلى حالتها السابقة لتنفيذ الدالة pop بعد تنفيذ الدالة append على النحو التالي:

li.append(3)    # li is now [1, 2, 4, 3] again.

تستطيع التعامل مع القائمة مثل المصفوفة من حيث الوصول لعناصرها:

li[0]   # => 1
li[-1]  # => 3

في حال استخدام فهرس خارج حدود القائمة سينتج خطأ من نوع IndexError:

li[4]  # Raises an IndexError

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

li[1:3]   # => [2, 4]

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

في حال عدم استخدام فهرس النهاية:

li[2:]    # => [4, 3]

في حال عدم استخدام فهرس البداية:

li[:3]    # => [1, 2, 4]

اختيار عنصر كل خطوتين ابتداء من العنصر الأول في القائمة:

li[::2]   # =>[1, 4]

إرجاع كامل المصفوفة بطريقة عكسية:

li[::-1]  # => [3, 4, 2, 1]

القاعدة العامة للاستعلامات السابقة في القوائم هي كالتالي(البداية start، النهاية end والخطوة step):

# li[start:end:step]

نسخ عميق (Deep Copy):

li2 = li[:]  # => li2 = [1, 2, 4, 3]

عندما نفحص المساواة باستخدام عملية is كالتالي: (li2 is li) ستكون النتيجة False.

لحذف عنصر من القائمة:

del li[2]  # li is now [1, 2, 3]

لحذف أول عنصر في القائمة يساوي القيمة المدخلة في الدالة remove:

li.remove(2)  # li is now [1, 3]
li.remove(2)  # ValueError لأن القيمة غير موجودة

إضافة عنصر في مكان معين في القائمة:

li.insert(1, 2)  # li is now [1, 2, 3] again

الحصول على فهرس أول عنصر في القائمة يساوي القيمة المعطاة:

li.index(2)  # => 1
li.index(4)  # ValueError لأن القيمة غير موجودة

لإضافة قائمة لقائمة وإرجاع النتيجة كقائمة جديدة:

li + other_li  # => [1, 2, 3, 4, 5, 6]

لتمديد قائمة وإضافة قائمة إليها:

li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]

لفحص وجود قيمة في القائمة:

1 in li  # => True

للحصول على حجم القائمة (عدد العناصر التي بها):

len(li)  # => 6

نوع البيانات Tuple تشبه القائمة ولكنها غير قابلة للتعديل (ثابتة-immutable):

tup = (1, 2, 3)
tup[0]      # => 1
tup[0] = 3  # Raises a TypeError

لاحظ أنه في حالة وجود عنصر واحد في tuple لابد من وضع فاصلة عادية بعد العنصر، أما في حالة وجود أكثر من عنصر فتصبح الفاصلة إضافية:

type((1))   # => <class 'int'>
type((1,))  # => <class 'tuple'>
type(())    # => <class 'tuple'>

تستطيع تنفيذ أغلب عمليات القوائم على النوع Tuple:

len(tup)         # => 3
tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
tup[:2]          # => (1, 2)
2 in tup         # => True

تستطيع تفريغ (unpacking) محتويات Tuples وكذلك القوائم في متغيرات كما في الأمثلة التالية:

a, b, c = (1, 2, 3)  # a = 1, b = 2, c = 3
a, *b, c = (1, 2, 3, 4)  # a = 1, b = [2, 3], c = 4

عند عدم استخدام الأقواس فإن نوع البيانات التلقائي الذي سيتم استخدامه هو Tuple:

d, e, f = 4, 5, 6

تبديل قيم المتغيرات بطريقة سهلة:

e, d = d, e  # d = 5, e = 4

القواميس عبارة عن مؤشرات (مُخططات) من المفاتيح للقيم (كل مفتاح يؤشر على قيمة خاصة به).
تعريف قاموس فارغ:

empty_dict = {}

تعريف قاموس بقيم مسبقة:

filled_dict = {"one": 1, "two": 2, "three": 3}

لاحظ أن المفاتيح في القواميس لابد أن يكون نوع بياناتها ثابتا (immutable) وذلك لضمان الحصول على مفتاح ثابت (لا تتغير قيمته).
أنواع البيانات الثابتة والتي من الممكن استخدامها هي int , float, string, tuple.

invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.

يمكن للقيم – عكس المفاتيح – أن تكون من أي نوع.
للبحث عن قيم نستخدم الأقواس المعكوفة:

filled_dict["one"]  # => 1

للحصول على مفاتيح قاموس على شكل قائمة (الترتيب في القواميس غير ثابت):

list(filled_dict.keys())  # => ["three", "two", "one"]

للحصول على قيم قاموس على شكل قائمة:

list(filled_dict.values())  # => [3, 2, 1]

للتأكد من وجود مفتاح قاموس معين:

"one" in filled_dict  # => True
1 in filled_dict      # => False

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

filled_dict["four"]  # KeyError

استخدم الدالة get لتجنب الخطأ السابق:

filled_dict.get("one")      # => 1
filled_dict.get("four")     # => None

تدعم الدالة get إعادة قيمة تلقائية في حالة عدم وجود المفتاح:

filled_dict.get("one", 4)   # => 1
filled_dict.get("four", 4)  # => 4

تضيف الدالة setdefault المفتاح المُمرر إلى القاموس في حالة عدم وجوده. تضيف التعليمة التالية مفتاحا باسم five وتعطيه قيمة 5، أما التعليمة الثانية فلا تحدت تغييرا على القاموس.

filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5

للإضافة إلى القاموس:

filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict["four"] = 4         # طريقة أخرى

حذف المفتاح من القاموس:

del filled_dict["one"]  # Removes the key "one" from filled dict

بعض طرق التفريغ في القواميس:

{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}}  # => {'a': 2}

المجموعات:

empty_set = set()
some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}

نوع البيانات الخاص بعناصر المجموعات لابد أن يكون ثابتا:

invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}

للإضافة إلى المجموعة:

filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}

إجراء عملية التقاطع بين مجموعتين:

other_set = {3, 4, 5, 6}
filled_set & other_set  # => {3, 4, 5}

إجراء عملية الاتحاد بين مجموعتين:

filled_set | other_set  # => {1, 2, 3, 4, 5, 6}

إجراء عملية الطرح بين مجموعتين:

{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}

لإجراء عملية فرق التماثل بين مجموعتين:

{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}

لفحص إذا كانت المجموعة على الشمال هي مجموعة تحتوي المجموعة على اليمين أم لا:

{1, 2} >= {1, 2, 3} # => False

عكس المثال السابق:

{1, 2} <= {1, 2, 3} # => True

فحص وجود قيمة في مجموعة:

2 in filled_set   # => True
10 in filled_set  # => False

جمل التحكم

some_var = 5

جملة if:

if some_var > 10:
    print("قيمة المتغيّر أكبر تماما من 10")
elif some_var < 10:    # هذه الجملة اختيارية
    print("قيمة المتغيّر أصغر من 10")
else:                  # هذه الجملة اختيارية    print("قيمة المتغيّر تساوي 10")

جملة for:

for animal in ["dog", "cat", "mouse"]:
    print("{} is a mammal".format(animal))

لاحظ استخدام الدالة format في جملة for السابقة. يمكن أيضا تطبيق الجملة على مجال عددي range:

for i in range(4):
    print(i)

for i in range(4, 8):
    print(i)

for i in range(4, 8, 2):
    print(i)

جملة while:

x = 0
while x < 4:
    print(x)
    x += 1  # اختصارا ل x = x + 1

معالجة الأخطاء باستخدام try/except (استخدم raise لتوليد الخطأ):

try:
        raise IndexError("This is an index error")
except IndexError as e:
    pass                 except (TypeError, NameError):
    pass                 
else:                    
    print("All good!")   
finally:                 
    print("We can clean up resources here")

ملاحظات حول معالجة الأخطاء:

1. Pass تعني عدم وجود عملية للتنفيذ.
2. تستطيع سرد أكثر من نوع خطأ في جملة except.
3. تستطيع استخدام جملة else مع try/except اختياريا (تنفذ في حالة كانت الشفرة البرمجية في try لم تُصدر أي خطأ).
4. نستخدم جملة finally لتنفيذ شفرة برمجية بعد try/except بغض النظر عن وجود أخطاء أم لا، وعادةً يُعاد تحرير المصادر المستخدمة.

بدلا من استخدام جملة finally لإعادة تحرير المصادر المستخدمة، تستطيع استخدام جملة with:

with open("myfile.txt") as f:
    for line in f:
        print(line)

تُقدم البايثون كائنًا متُعددًا (Iterable) وهو كائن مجرد (عام) يُتعامل معه مثل sequence. فمثلا الكائن المُرجع من الدالة range هو كائن مُتعدد:

filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
print(our_iterable)  # => dict_keys(['one', 'two', 'three']).

تستطيع المرور على عناصر الكائن المتعدد والتعامل معها:

for i in our_iterable:
    print(i)  # Prints one, two, three

على الرغم من خاصية الكائن المتعدد، إلا أنه لا تستطيع استخدام الفهرس معه:

our_iterable[1]  # Raises a TypeError

تستطيع الحصول من خلال الكائن المُتعدد على كائن iterator منه بحيث تستطيع المرور على عناصره:

our_iterator = iter(our_iterable)

يحتفظ الكائن iterator بحالته كلما تم استخدامه، فمثلا، باستخدام وظيفة next تستطيع الحصول على العنصر التالي في هذا الكائن:

next(our_iterator)  # => "one"
next(our_iterator)  # => "two"
next(our_iterator)  # => "three"

بعد الحصول على كافة عناصر iterator فإن استخدام الدالة next سيعيد خطأ:

next(our_iterator)  # Raises StopIteration

تستطيع الحصول على كافة عناصر iterator دفعة واحدة على شكل قائمة وذلك باستخدام الدالة list :

list(filled_dict.keys())  # => Returns ["one", "two", "three"]

الدوال

نستخدم الكلمة def في تعريف الدالة، ونستخدم كلمة return في إرجاع النتيجة:

def add(x, y):
    print("x is {} and y is {}".format(x, y))
    return x + y  

تطبع الدالة السابقة قيمتيْ المعامليْن المُمرّرين لها وتعيد ناتج جمعهما:

add(5, 6)  # => prints out "x is 5 and y is 6" and returns 11

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

add(y=6, x=5)  

تستطيع تعريف دالة باستقبال عددًا غير محدد من المعاملات:

def varargs(*args):
    return args

varargs(1, 2, 3)  # => (1, 2, 3)

من الممكن استخدام المعاملات المُسماة لاستقبال عدد غير محدد من المعاملات أيضا:

def keyword_args(**kwargs):
    return kwargs

keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}

كما نستطيع دمج الطريقتين في نفس الدالة:

def all_the_args(*args, **kwargs):
    print(args)
    print(kwargs)
all_the_args(1, 2, a=3, b=4) # =>  
    (1, 2)
    {"a": 3, "b": 4}

توجد طريقة أخرى لاستدعاء الدوال باستخدام args/kwargs وذلك عندما تكون المعطيات من النوع tuple أو قاموس:

args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)            # equivalent to foo(1, 2, 3, 4)
all_the_args(**kwargs)         # equivalent to foo(a=3, b=4)
all_the_args(*args, **kwargs)  # equivalent to foo(1, 2, 3, 4, a=3, b=4)

يمكن أيضا إرجاع نتيجة من قيم متعددة على شكل tuple:

def swap(x, y):
    return y, x  

x = 1
y = 2
x, y = swap(x, y)     # => x = 2, y = 1

يختلف المتغيّر في نطاق scope الدالة عن المتغيّرات العامة Global:

x = 5
def set_x(num):
    x = num    # => 43
    print(x)   # => 43

تُستخدَم الكلمة المفتاحية global لتعريف متغيّر عام من داخل الدالة:

def set_global_x(num):
    global x
    print(x)   # => 5
    x = num    # هذا المتغير يمثل المتغير على النطاق العام وقيمته الان 6
    print(x)   # => 6

set_x(43)
set_global_x(6)

تعدّ الدوال في بايثون كائنات من الفئة الأولى:

def create_adder(x):
    def adder(y):
        return x + y
    return adder

add_10 = create_adder(10)
add_10(3)   # => 13

كما يمكنك تعريف دوال غير مسمّاة Anonymous functions:

(lambda x: x > 2)(3)                  # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5

ويمكنك تمرير الدالة معاملا لدالة أخرى:

list(map(add_10, [1, 2, 3]))          # => [11, 12, 13]
list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]

list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]

تستطيع استخدام مبدأ “تفهيم القائمة” للحصول على نفس نتيجة الدوال map و filter:

 [add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]

تستطيع استخدام مبدأ “تفيهم القاموس” و “تفهيم المجموعة” كذلك:

{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

الوحدات Modules

الوحدات في بايثون عبارة عن ملفات بايثون عادية. تستطيع أن تكتب الوحدة الخاصة بك وتستوردها في الشفرة البرمجة الخاصة بمشروعك. اسم الوحدة سيكون نفس اسم الملف الذي أنشأته لهذا الغرض.
تُستورَد الوحدات بالطريقة التالية:

import math
print(math.sqrt(16))  # => 4.0

تستطيع الحصول على دوال محددة من الوحدات:

from math import ceil, floor
print(ceil(3.7))   # => 4.0
print(floor(3.7))  # => 3.0

تستطيع استيراد جميع الدوالّ من الوحدة دفعة واحدة ولكن هذا الأمر غير منصوح به:

from math import *

تستطيع اختصار أسماء الوحدات عند استيرادها:

import math as m
math.sqrt(16) == m.sqrt(16)  # => True

تُستخدَم الدالة المضمنة dir لمعرفة مكان ملف الوحدة.

import math
dir(math)

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

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

الأصناف Classes

نستخدم كلمة class لتعريف صنف:

class Human:

لتعريف خاصية للصنف (هذه الخاصية تكون مُشاركة بين كل العناصر المتولدة من هذا الصنف):

species = "H. sapiens"

init هو المشيّدات Constructor الأساسي ويُستدعى عند توليد عنصر من الصنف. التسطير السفلي المكرر مرتين قبل كلمة init وبعدها يدل على أن هذا الكائن أو الخاصية يستخدمه بايثون ولا يجب علينا استخدامها مباشرة.

    def __init__(self, name):
        # إعطاء قيمة المعطى للخاصية الموجودة في الصنف
        self.name = name

        # قيمة مبدئية
        self._age = 0

الدالة say هي تابع عيّنة Instance method، أي أن لكل كائن نسخة خاصة به منها. تأخذ هذه التوابع أن self في أول معامل يُمرّر لها:

    def say(self, msg):
        print ("{name}: {message}".format(name=self.name, message=msg))

        def sing(self):
        return 'yo... yo... microphone check... one two... one two...'

يمكن أيضا تعريف تابع متشارك بين كل كائنات الصنف:

    @classmethod
    def get_species(cls):
        return cls.species

نستطيع كذلك تعريف تابع ساكن يُستدعى دون الحاجة لإنشاء كائن من الصنف:

    @staticmethod
    def grunt():
        return "*grunt*"

يحوّل التعليمة property@ دالة إلى خاصيّة للقراءة فقط لها نفس اسم الدالة، لتؤدّي بالتالي وظيفة المسترجعات Getters.

    @property
    def age(self):
        return self._age

يمكننا جعل الخاصية قابلة للتعيين لتصبح الدالة تعمل معدّلا Setter:

    @age.setter
    def age(self, age):
        self._age = age

كما يمكننا السماح بحذفها:

    @age.deleter
    def age(self):
        del self._age

يقوم مُفسر البايثون بتنفيذ كافة اشيفرة البرمجية في ملف الوحدة الذي يقرأه، ومن خلال الخاصية name نتأكد من أن كتلة الشفرة البرمجية التي في جملة الشرط ستُنفَّذ في حال كانت الوحدة هي البرنامج الرئيسي المُنفذ:

if __name__ == '__main__':
    i = Human(name="Ian")
    i.say("hi")               # "Ian: hi"
    j = Human("Joel")
    j.say("hello")            # "Joel: hello"

    # استدعاء دالة الفئة
    i.say(i.get_species())          # "Ian: H. sapiens"

 # تغيير الخاصية المشتركة
    Human.species = "H. neanderthalensis"
    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
    j.say(j.get_species())          # => "Joel: H. neanderthalensis"

    # استدعاء الدالة الساكنة
    print(Human.grunt())            # => "*grunt*"

لا تستطيع استدعاء الدالة الساكنة من خلال العنصر المتولد i لأن استدعاءها بهذه الطريقة سيضيف self كمعامل لها مما سينتج عنه خطأ:

    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given

    i.age = 42
    i.say(i.age)                 # => "Ian: 42"
    j.say(j.age)                 # => "Joel: 0"
    del i.age
    # i.age                         # => this would raise an AttributeError

ترجمة -وبتصرف- للمقال Learn X in Y minutes Where X=Python3

اقرأ أيضا:

• تعلم لغة بايثون

تمهيد

بايثون هي أداةٌ رائعةٌ لمعالجة البيانات. ومن المحتمل أنَّ البرامج التي تكتبها ستتضمن قراءة البيانات أو كتابتها أو تعديلها، ولهذا السبب ستستفيد جدًا من قدرة بايثون على التعامل مع مختلف صيغ الملفات التي تُخزِّن أصنافًا متنوعةً من البيانات.

ليكن لديك -على سبيل المثال- برنامج بايثون الذي يتحقق من امتيازات الوصول لقائمة من المستخدمين؛ فيكون من المرجح في هذه الحالة أن تُخزَّن قائمة المستخدمين في ملفٍ نصيٍ بسيط. أو ربما لم تكن تتعامل مع النصوص، وإنما مهمة برنامجك هي التحليل الاقتصادي؛ ومن المرجح أنَّك ستأخذ الأرقام التي ستجري عملياتك عليها من ورقة عمل في أحد البرامج مثل Excel أو Calc. وأرى أنَّه من المرجح أن يتطلب تطبيقك إدخال أو إخراج البيانات بغض النظر عن الهدف منه.
سيشرح هذا الدرس باختصار بعض الصيغ التي تستطيع بايثون التعامل معها. سنستعرض أولًا لمحة عن بعض أنواع الملفات، ثم سنكمل الدرس بكيفية فتح وقراءة الملفات والكتابة إليها في بايثون 3.
يجب أن تُصبح قادرًا بعد نهاية هذا الدرس على التعامل مع أيّة ملفات نصية في بايثون.

المتطلبات المسبقة

ستحتاج في هذا الدرس إلى توافر بايثون 3 على حاسوبك بالإضافة إلى بيئة برمجية محلية مضبوطة عليه.
لغة بايثون هي لغة متكاملة وتستطيع التعامل بسهولة (نسبيًا) مع مختلف صيغ الملفات، بما فيها الصيغ الآتية:

• txt: ملف نصي بسيط يُخزِّن البيانات التي تُمثِّل المحارف (أو السلاسل النصية) ولا تضم أيّة بيانات وصفية.
• CSV: ملف يحتوي قيمًا مفصولٌ بينها بفاصلة (أو غيرها من المحارف التي تستعمل لفصل الحقول) لتنظيم بُنية هيكلية للبيانات، مما يسمح بحفظ المعلومات بصيغةٍ مجدولة.
• HTML: لغة توصيفية تُخزِّن البيانات الهيكلية وتستعمل عادةً لبناء صفحات الويب.
• JSON: صيغة بسيطة وعملية، مما يجعلها أشهر الصيغ المستعملة لتخزين ونقل البيانات.

سنُركِّز في هذا الدرس على صيغة txt.

الخطوة الأولى: إنشاء ملف نصي

قبل أن نبدأ بإنشاء برامج بايثون، سنحتاج إلى ملفٍ نصيٍ لنعمل عليه؛ لذا افتح محررك النصي المُفضَّل وأنشِئ ملف txt جديد واجعل اسمه days.txt.
أدخِل في الملف الجديد بضعة أسطر، ولتكن مثلًا أيام الأسبوع:

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

احفظ الآن الملف وانتبه إلى مكان تخزينه. فمثلًا، كان اسم المستخدم في نظامي هو sammy وحفظتُ الملف في المسار ‎/users/sammy/days.txt. هذا المسار مهمٌ جدًا في الخطوات القادمة، لأننا سنحاول فتحه باستخدام بايثون.
بعد أن حصلنا على ملفٍ نصيٍ لنعمل عليه، فلنبدأ عملية كتابة البرنامج.

الخطوة الثانية: فتح الملف

قبل أن نبدأ بكتابة البرنامج علينا إنشاء ملف لحفظه، لذا سنُنشِئ الملف files.py في المحرر النصي. وللتبسيط سنضعه في نفس المجلد الذي يحتوي الملف days.txt: أي ‎/users/sammy/‎.
علينا لنفتح ملف في بايثون أن نعثر على طريقةٍ لربط الملف الموجود على القرص الصلب بأحد المتغيرات. تدعى هذه العملية «بفتح» الملف. سنبدأ بإخبار بايثون أين يوجد الملف، ويُشار عادةً إلى مكان تخزين الملف بالمصطلح «المسار» (path). ولكي تستطيع لغة بايثون أن تفتح لك الملف، فستحتاج إلى مساره. ومسار الملف days.txt كما ذكرنا في القسم السابق هو ‎/users/sammy/days.txt، وسنُنشِئ متغيرًا لتخزين هذا المسار باسم path في ملف files.py وضبط قيمته إلى مسار الملف days.txt:

path = '/users/sammy/days.txt'

سنستخدم بعد ذلك الدالة open()‎ الموجودة في بايثون لفتح الملف days.txt. تتطلب الدالة open()‎ تمرير مسار الملف كأوّل وسيط (argument) لها، لكنها تقبل عددًا كبيرًا من المعاملات (parameters)؛ لكن أهم معامل منها هو المعامل الاختياري الذي يُحدِّد «نمط» فتح الملف (opening mode)، فالنمط هو سلسلةٌ نصيةٌ تُحدِّد ماذا تستطيع أن تفعله مع الملف. هذه قائمة ببعض الأنماط المتوافرة:

• 'r': فتح الملف للقراءة
• 'w': فتح الملف للكتابة
• 'x': إنشاء الملف وفتحه للكتابة
• 'a': الإضافة إلى نهاية الملف
• 'r+‎': فتح الملف للقراءة والكتابة معًا

أريد أن أقرأ من الملف فقط في المثال الآتي، لذا سأستخدم النمط r. سنستعمل الدالة open()‎ لفتح الملف days.txt وإسناده إلى المتغير days_file.

days_file = open(path,'r')

نستطيع الآن بعد فتح الملف أن نقرأ منه، وهذا ما سنناقشه في القسم التالي.

الخطوة الثالثة: قراءة الملف

نستطيع الآن بعد فتح الملف أن نُجري عمليات عليه (مثلًا: أن نقرأ منه) عبر المتغير الذي أسندناه إليه. توفِّر بايثون ثلاثة عمليات متعلقة بقراءة المعلومات من ملف، وسأريك إياها كلها في أمثلةٍ لتفهم كيف تعمل.
أوّل عملية هي ‎<file>.read()‎ التي تُعيد كامل محتويات الملف كسلسلةٍ نصيةٍ وحيدة.

days_file.read()

الناتج:

'Monday\nTuesday\nWednesday\nThursday\nFriday\nSaturday\nSunday\n'

العملية الثانية ‎<file>.readline()‎ تُعيد السطر التالي من الملف، حيث تُعيد السطر بأكمله بالإضافة إلى محرف السطر الجديد. ببساطة: هذه العملية ستؤدي إلى قراءة الملف سطرًا بسطر.

days_file.readline()

الناتج:

'Monday\n'

وبعد أن تقرأ سطرًا عبر readline()‎ فسيتم الانتقال إلى السطر الذي يليه، فلو استدعيتَ هذه العملية مرةً أخرى، فستُعيد السطر الذي يلي السطر السابق في الملف كما في الناتج الآتي:

'Tuesday\n'

آخر عملية هي ‎<file>.readlines()‎ التي تُعيد قائمةً (list) بجميع الأسطر الموجودة في الملف، حيث يُمثَّل كل سطر في الملف بعنصرٍ في القائمة.

days_file.readlines()

الناتج:

['Monday\n', 'Tuesday\n', 'Wednesday\n', 'Thursday\n', 'Friday\n', 'Saturday\n', 'Sunday\n']

أحد الأمور التي يجب عليك أن تبقيها في ذهنك عند القراءة من الملفات هو عدم قدرتك على إعادة قراءة الملف بعد استخدام إحدى عمليات القراءة السابقة. فمثلًا لو استدعيتَ days_file.read()‎ متبوعةً بالدالة days_file.readlines()‎ فستُعيد العملية الثانية سلسلةً نصيةً فارغةً، وبالتالي ستحتاج إلى إنشاء متغير جديد مرتبط بالملف في كل مرة ترغب فيها بقراءته.
بعد أن تعلمنا طرائق القراءة من ملف فحان الوقت الآن إلى تعلم كيفية الكتابة إلى ملفٍ جديد.

الخطوة الرابعة: الكتابة إلى ملف

سنكتب الآن السلسلة النصية «Days of the Week» إلى ملفٍ جديد متبوعةً بأيام الأسبوع. سنُنشِئ بادئ الأمر المتغير title:

title = 'Days of the Week\n'

سنحتاج أيضًا إلى تخزين أيام الأسبوع في متغيرٍ الذي سنسميه days. ولتبسيط ذلك سنضع نفس الشيفرة التي استخدمناها في القسم أعلاه؛ حيث سنفتح الملف بنمط القراءة ثم نقرأه ونُخزِّن ناتج عملية القراءة في المتغير الجديد days:

path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()

أصبح لدينا الآن متغيران أولهما للعنوان والآخر لأيام الأسبوع، لذا نستطيع البدء بالكتابة إلى الملف الجديد. لكننا سنحتاج أولًا إلى تحديد مسار الملف، وسنستخدم المجلد ‎/users/sammy مجددًا، ثم سنُحدِّد اسم الملف الجديد الذي نود إنشاءه؛ لذا سيكون المسار النهائي هو ‎/users/sammy/new_days.txt، وسنضع هذا المسار في المتغير new_path، ثم سنفتح الملف الجديد بنمط الكتابة، وذلك باستخدام الدالة open()‎ مع النمط w:

new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')

من المهم أن تعلم أنَّه لو كان الملف new_days.txt موجودًا من قبل «فتح» الملف، فستُحذف جميع محتوياته السابق، لذا توخى الحذر عند استخدام النمط w.
بعد أن فتحنا الملف للقراءة، سنستطيع الآن أن نكتب البيانات فيه وذلك باستخدام الدالة ‎<file>.write()‎. تأخذ دالة الكتابة معاملًا وحيدًا الذي يجب أن يكون سلسلةً نصية وتكتبه إلى الملف. إذا أردتَ أن تبدأ سطرًا جديدًا في الملف، فعليك توفير محرف بداية السطر (newline) يدويًا.
سنكتب أولًا العنوان إلى الملف متبوعًا بأيام الأسبوع. ولنضف أيضًا بعض تعبيرات print لنعرف ما الذي سيُكتَب إلى الملف، وهذا أمرٌ مستحسنٌ لكي تتتبع مسار تنفيذ برنامجك.

new_days.write(title)
print(title)

new_days.write(days)
print(days)

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

الخطوة الخامسة: إغلاق الملف

عملية إغلاق الملف تعني إغلاق قناة التواصل بين الملف على القرص وبين المتغير الموجود في برنامجك. إغلاق الملفات يعني أنَّ البرامج الأخرى ستتمكن من الوصول إلى الملف وستُبقي بياناتك بأمان؛ لذا احرص دومًا على إغلاق الملفات التي تفتحها؛ وهذا ما سنفعله في الأسطر الآتية عبر استعمال الدالة ‎<file>.close()‎:

days_file.close()
new_days.close()

أنهينا عملية معالجة الملفات في بايثون، ولننظر الآن إلى الشيفرة النهائية.

الخطوة السادسة: التحقق من سلامة الشيفرة

قبل أن تجرِّب الشيفرة تأكَّد أنَّ كل شيء يبدو سليمًا. يجب أن تكون الشيفرة النهائية شبيهةً بما يلي:

path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()


new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')

title = 'Days of the Week\n'
new_days.write(title)
print(title)

new_days.write(days)
print(days)

days_file.close()
new_days.close()

بعد أن تحفظ الشيفرة في ملفها، فافتح الطرفية (terminal) وشغِّل سكربت بايثون:

python files.py

يجب أن يبدو الناتج كما يلي:

Days of the Week

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

لنتحقق الآن من أنَّ الشيفرة تعمل كما ينبغي لها وذلك بفتح الملف الجديد المُنشَأ new_days.txt فلو نُفِّذ البرنامج تنفيذًا صحيحًا فيجب أن تكون مخرجاته كالآتي:

Days of the Week
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

إذا ظهر معك نفس الناتج السابق فأود أن أهنِّئك على إتمامك لهذا الدرس بنجاح.

الخلاصة

تعلمنا في هذا الدرس كيفية التعامل مع الملفات النصية البسيطة في بايثون 3 ومعالجتها. يمكنك الآن أن تفتح الملفات وتقرأها وتكتب إليها ثم تغلقها. جرِّب ما تعلمته في هذا الدرس على ملفات التي تريد معالجتها واسأل إن واجهتَ صعوبةً في ذلك.
ترجمة -وبتصرّف- للمقال How To Handle Plain Text Files in Python 3 لصاحبته Michelle Morales

سنشرح في هذا الدرس كيفية إعداد بيئة برمجية محليّة للغة بايثون 3 في توزيعة أوبنتو 16.04 أو دبيان 8.
بايثون هي لغةٌ سهلة القراءة للغاية ومتنوعة ومتعددة الاستخدامات، واسمها مستوحى من مجموعة كوميدية بريطانية باسم «Monty Python»، وكان أحد الأهداف الأساسية لفريق تطوير بايثون هو جعل اللغة مرحةً وسهلة الاستخدام، وإعدادها بسيطٌ، وطريقة كتابتها مباشرة وتعطيك تقريرًا مباشرًا عند حدوث أخطاء، وهي خيارٌ ممتازٌ للمبتدئين والوافدين الجدد على البرمجة. إصدار بايثون 3 هو الإصدار الحالي من اللغة ويُعتَبَر أنَّه مستقبل بايثون.
سيُرشِدُك هذا الدرس خطوةً بخطوة إلى كيفية تثبيت بايثون 3 على نظام لينكس المحلي عندك وذلك عبر سطر الأوامر، وصحيحٌ أنَّ هذا الدرس يشرح عملية التثبيت لتوزيعة أوبنتو 16.04 أو دبيان 8، إلا أنَّ المفاهيم الأساسية فيه تنطبق على أيّة توزيعة أخرى.

المتطلبات المسبقة

يجب أن يكون لديك حاسوبٌ يعمل بتوزيعة أوبنتو 16.04 أو دبيان 8 (أو أيّ إصدار آخر من دبيان)، وأن تكون لديك امتيازات إدارية على النظام، بالإضافة إلى اتصالٍ بالإنترنت.

الخطوة الأولى: إعداد بايثون 3

سنُثبِّت ونضبط بايثون عبر سطر الأوامر، والذي هو طريقةٌ غيرُ رسوميةٍ للتعامل مع الحاسوب، فبدلًا من الضغط على الأزرار فستكتب نصًا وتعطيه للحاسوب لينفذه وسيُظهِر لك ناتجًا نصيًا أيضًا. يمكن أن يساعدك سطر الأوامر على تعديل أو أتمتة مختلف المهام التي تنجزها على الحاسوب يوميًا، وهو أداةٌ أساسيةٌ لمطوري البرمجيات، وهنالك الكثير من الأوامر التي عليك تعلمها لكي تتمكن من الاستفادة منه. هنالك مقالات في أكاديمية حسوب (كدرس مدخل إلى طرفيّة لينكس Linux Terminal) ستعلمك أساسيات سطر الأوامر، وهنالك كتاب «سطر أوامر لينكس» الذي يُعتَبر مرجعًا تفصيلًا لطريقة التعامل مع سطر الأوامر.
ستجد تطبيق «Terminal» (البرنامج الذي تستعمله للوصول إلى سطر الأوامر) بالضغط على أيقونة Dash في الزاوية العليا اليسرى من الشاشة ثم كتابة «terminal» في شريط البحث، ثم الضغط على أيقونة التطبيق التي ستظهر بعدئذٍ. يمكنك بشكلٍ بديلٍ أن تضغط على Ctrl+Alt+T في لوحة المفاتيح بنفس الوقت لتشغيل تطبيق Terminal.

أما على دبيان 8 فيمكنك فتح القائمة الموجودة أيضًا في الزاوية العليا اليسرى من الشاشة ثم البحث عن «terminal» في شريط البحث، ثم النقر على أيقونة التطبيق. يمكنك أيضًا أن تضغط على Ctrl+Alt+T في لوحة المفاتيح بنفس الوقت لتشغيل تطبيق Terminal.

تأتي توزيعات أوبنتو 16.04 ودبيان 8 وإصدارات دبيان الأخرى مثبتةً مسبقًا مع بايثون 3 وبايثون 2. للتأكد أنَّك تملك آخر الإصدارات منها فحدِّث نظامك باستخدام apt-get:

sudo apt-get update
sudo apt-get -y upgrade

الخيار ‎-y يعني أنَّك توافق على تثبيت جميع الحزم القابلة للتحديث، لكن قد تحتاج إلى تأكيد ذلك عند تحديث النظام وذلك اعتمادًا على الحزم التي ستُحدَّث ونسخة نظامك.
بعد إكمال العملية، يمكننا التحقق من إصدار بايثون 3 المُثبّت في النظام بكتابة:

python3 -V

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

Python 3.5.2

لإدارة الحزم البرمجية الخاصة ببايثون، فثبّت pip:

sudo apt-get install -y python3-pip

الأداة pip هي أداةٌ تعمل مع لغة بايثون تُثَبِّت وتدير الحزم البرمجية التي قد نحتاج إلى استخدامها في تطوير مشاريعنا. يمكنك تثبيت حزم بايثون بكتابة الأمر:

pip3 install package_name

حيث عليك وضع اسم الحزمة أو المكتبة التابعة لبايثون مكان package_name مثل Django لتطوير الويب أو NumPy لإجراء حسابات علمية. لذا إن شئتَ تنزيل NumPy فيمكنك تنفيذ الأمر pip3 install numpy.
بعد أن انتهينا من ضبط بايثون وتثبيت pip، فيمكننا الآن إنشاء «بيئة وهمية» (virtual environment) لمشاريعنا.

الخطوة الثانية: إعداد بيئة وهمية

تُمكِّنك البيئات الوهمية من إنشاء مساحة معزولة في حاسوبك مخصصة لمشاريع بايثون، مما يعني أنَّ كل مشروع تعمل عليه يملك مجموعة من الاعتماديات (dependencies) والتي لن تؤثِّر على غيره من المشاريع.
يوفِّر لنا ضبط بيئةٍ برمجيةٍ تحكمًا أكبر بمشاريع بايثون وإمكانية التعامل مع إصداراتٍ مختلفةٍ من حزم بايثون. وهذا مهمٌ كثيرًا عندما تتعامل مع الحزم الخارجية.
يمكنك ضبط أيُّ عددٍ تشاء من البيئات الوهمية، وكل بيئة تُمثِّل مجلدًا في حاسوبك الذي فيه عددٌ من السكربتات.
علينا أولًا تثبيت وحدة (module) برمجية باسم venv، وهي جزءٌ من مكتبة بايثون3 القياسية، وذلك لكي نتمكن من استخدام الأمر pyvenv الذي سيُنشِئ البيئات الوهمية لنا. لنثبِّت venv على نظامنا بكتابة:

sudo apt-get install -y python3-venv

سنتمكن الآن من إنشاء بيئات وهمية بعد إتمام التثبيت، لنختار ما هو المجلد الذي سنضع فيه بيئات بايثون، أو لننشِئ مجلدًا جديدًا باستخدام الأمر mkdir كما يلي:

mkdir environments
cd environments

بعد أن انتقلتَ إلى المجلد الذي تريد احتواء البيئات فيه، فتستطيع الآن إنشاء بيئة جديدة بتنفيذ الأمر الآتي:

pyvenv my_env

سيُنشِئ الأمر pyvenv مجلدًا جديدًا فيه بعض الملفات التي يمكننا عرضها باستخدام الأمر ls:

ls my_env

bin include lib lib64 pyvenv.cfg share

تعمل هذه الملفات مع بعضها لضمان أنَّ مشاريعك معزولةٌ عن بقية النظام، لكي لا تختلط ملفات النظام مع ملفات المشاريع. وهذا أمرٌ حسنٌ لإدارة الإصدارات ولضمان أنَّ كل مشروع يملك وصولًا إلى حزمٍ معيّنة التي يحتاج لها. تتوافر أيضًا Python Wheels والتي هي صيغة بناء حزمٍ لبايثون والتي يمكن أن تُسرِّع من تطوير البرامج بتقليل عدد المرات التي تحتاج فيها إلى بناءٍ (compile) للمشروع، وهي موجودةٌ في مجلد share في توزيعة أوبنتو 16.04 لكنها ستكون في دبيان 8 في أحد مجلدات lib وليس في share.
عليك تفعيل البيئة لاستخدامها، وذلك بكتابة الأمر الآتي الذي سيُنفِّذ سكربت التفعيل:

source my_env/bin/activate

يجب أن تظهر الآن سابقةٌ (prefix) في المِحث (prompt) والتي هي اسم البيئة المستخدمة، وفي حالتنا هذه يكون اسمها my_env، وقد يكون مظهر المِحَث مختلفًا في توزيعة دبيان، وذلك اعتمادًا على الإصدار المستخدم؛ لكن يجب أن تشاهد اسم البيئة بين قوسين في بداية السطر:

(my_env) sammy@sammy:~/environments$

السابقة ستسمح لك بمعرفة أنَّ البيئة my_env مفعلة حاليًا، وهذا يعني أننا سنستخدم إعدادات وحزم هذه البيئة عند إنشائنا لمشاريع جديدة.
ملاحظة: يمكنك داخل البيئة الوهمية أن تستخدم الأمر python بدلًا من python3 والأمر pip بدلًا من pip3 إن شئتَ. أما إذا كنتَ ستستخدم بايثون 3 خارج البيئة الوهمية، فيجب عليك حينها استخدام python3 و pip3 حصرًا.
يجب أن تكون بيئتك الوهمية جاهزةً للاستخدام بعد اتباعك للخطوات السابقة.

الخطوة الثالثة: إنشاء برنامج بسيط

بعد أن أكملنا ضبط بيئتنا الوهمية، لننشِئ برنامجًا بسيطًا يعرض العبارة «Hello World!‎»، وبهذا سنتحقق من أنَّ البيئة تعمل عملًا صحيحًا، وستصبح طريقة إنشاء برامج بايثون مألوفةً لديك إن كنتَ وافدًا جديدًا على اللغة.
علينا أولًا تشغيل محرر ملفات نصية لإنشاء ملف جديد، وليكن المحرر nano الذي يعمل من سطر الأوامر:

(my_env) sammy@sammy:~/environments$ nano hello.py

بعد فتح الملف في نافذة الطرفية، فاكتب البرنامج الخاص بنا:

print("Hello, World!")

أغلق محرر nano بالضغط على Ctrl+x ثم اضغط على y عندما يسألك عن حفظ الملف.
بعد أن يُغلَق محرر nano وتعود إلى سطر الأوامر، فحاول تشغيل البرنامج:

(my_env) sammy@sammy:~/environments$ python hello.py

سيؤدي برنامج hello.py الذي أنشأتَه إلى طباعة الناتج الآتي في الطرفية:

Hello, World!

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

الخلاصة

تهانينا! لقد ضبطتَ الآن بيئة تطوير للغة بايثون 3 في جهازك الذي يعمل بتوزيعة أوبنتو أو دبيان، حان الآن الوقت للتعمق بلغة بايثون وإنشاء برامج رائعة! بالتوفيق.
ترجمة -وبتصرّف- للمقال How To Install Python 3 and Set Up a Local Programming Environment on Ubuntu 16.04 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيف تكتب أول برنامج لك
• المقالة السابقة: اعتبارات عملية للاختيار ما بين بايثون 2 و بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون