كيفية استخدام المتغيرات في بايثون 3

المتغيرات هي مفهوم برمجي مهم. إنَّها رموز تدل على القيم التي تستخدمها في برنامجك.

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

فهم المتغيرات

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

المُتغيِّر أشبه بعنوان تُلصقه على قيمة مُعيَّنة:

لنفترض أنّ لدينا عددًا صحيحًا يساوي 103204934813، ونريد تخزينه في متغيِّر بدلًا من إعادة كتابة هذا العدد الطويل كل مرة، لذلك سنستخدم شيئًا يُسهِّل تذكُّره، مثل المتغير my_int:

my_int = 103204934813

إذا نظرنا إليه على أنَّه عنوانٌ مرتبط بقيمة، فسيبدو على النحو التالي:

عنوان القيمة هو my_int المكتوب عليها، والقيمة هي 103204934813 (نوعها عدد صحيح).

العبارة my_int = 103204934813 هي تعليمة إسناد (assignment statement)، وتتألف من الأجزاء التالية:

اسم المتغير (my_int)
معامل الإسناد، المعروف أيضًا باسم "علامة المساواة" (=)
القيمة التي أُسنِدَت إلى اسم المتغير (103204934813)

تشكل هذه الأجزاء الثلاثة معًا العبارة التي تُسنِد على المتغير my_int القيمة العددية الصحيحة 103204934813 .

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

بمجرد تعيين my_int عند القيمة 103204934813، يمكننا استخدام my_int في مكان العدد الصحيح، كما في المثال التالي:

print(my_int)

والمخرجات هي:

103204934813

استخدام المتغيرات يسهل علينا إجراء العمليات الحسابية. في المثال التالي، سنستخدم العبارة السابقة my_int = 1040 ، ثم سنطرح من المتغير my_int القيمة 813 :

print(my_int - 813)

وسينتج لنا:

103204934000

في هذا المثال، يجري بايثون العملية الحسابية، ويطرح 813 من المتغير my_int ، ويعيد القيمة 103204934000 .

يمكن ضبط المتغيرات وجعلها تساوي ناتج عملية حسابية. دعنا نجمع عددين معًا، ونخزِّن قيمة المجموع في المتغير x :

x = 76 + 145

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

لنطبع x :

print(x)

والمخرجات:

أعادت بايثون القيمة 221 لأنَّه أُسنِد إلى المتغير x مجموع 76 و 145 .

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

my_string = 'Hello, World!'
my_flt = 45.06
my_bool = 5 > 9 # True أو False القيم المنطقية ستعيد إما
my_list = ['item_1', 'item_2', 'item_3', 'item_4']
my_tuple = ('one', 'two', 'three')
my_dict = {'letter': 'g', 'number': 'seven', 'symbol': '&'}

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

my_list = ['item_1', 'item_2', 'item_3', 'item_4']
print(my_list)

وسينتج لنا:

['item_1', 'item_2', 'item_3', 'item_4']

لقد مرّرنا القيمة ['item_1' و 'item_2' و 'item_3' و 'item_4'] إلى المتغير my_list، ثم استخدمنا الدالة print()‎ لطباعة تلك القيمة باستدعاء my_list.

تُخصِّص المتغيرات مساحة صغيرة من ذاكرة الحاسوب، وتقبل قيمًا تُوضَع بعد ذلك في تلك المساحة.

قواعد تسمية المتغيرات

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

يجب أن تكون أسماء المتغيرات من كلمة واحدة فقط (بدون مسافات)
يجب أن تتكوّن أسماء المتغيرات من الأحرف والأرقام والشرطة السفلية (_) فقط
لا ينبغي أن تبدأ أسماء المتغيرات برقم

باتباع القواعد المذكورة أعلاه، دعنا نلقي نظرة على بعض الأمثلة:

صالح	غير صالح	لماذا غير صالح
my_int	my-int	غير مسموح بالشرطات
int4	4int	لا يمكن البدء برقم
MY_INT	‎$MY_INT	لا يمكن استخدام أيّ رمز غير الشرطة السفلية
another_int	another int	المتغير لا ينبغي أن يتكون من أكثر من كلمة واحدة

من الأمور التي يجب أخذها في الحسبان عند تسمية المتغيرات، هو أنَّها حساسة لحالة الأحرف، وهذا يعني أنَّ my_int و MY_INT و My_Int و mY_iNt كلها مختلفة. ينبغي أن تتجنب استخدام أسماء متغيرات متماثلة لضمان ألا يحدث خلط عندك أو عند المتعاونين معك، سواء الحاليين والمستقبليّين.

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

تنسيق متعارف عليه	تنسيق غير متعارف عليه	لماذا غير متعارف عليه
my_int	myInt	أسلوب سنام الجمل (camelCase) غير تقليدي
int4	Int4	الحرف الأول كبير - غير تقليدية
my_first_string	myFirstString	أسلوب سنام الجمل (camelCase) غير تقليدي

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

يمكنك مراجعة مقالة تنسيق الشيفرات البرمجية في بايثون لمزيد من التفاصيل.

تغيير قيم المتغيرات

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

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

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

سنعيّن إلى المتغير x أولًا عددًا صحيحًا، ثم نعيد تعيينه بسلسلة نصية:

# x إسناد قيمة عددية إلى
x = 76
print(x)

# إلى سلسلة نصية x إعادة تعيين
x = "Sammy"
print(x)

وسينتج لنا:

76
Sammy

يوضح المثال أعلاه أنه يمكننا أولًا تعيين المتغير x وإعطاؤه قيمة عددية، ثم إعادة تعيينه بقيمة نصية.

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

x = 76
x = "Sammy"
print(x)

لن نتلقى سوى القيمة المعيّنة الثانية في المخرجات، لأنَّ تلك القيمة كانت أحدث تعيين:

Sammy

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

الإسناد المتعدد (Multiple Assignment)

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

يمكنك من خلال التعيينات المتعددة ضبط المتغيرات x وy و z عند القيمة 0 في سطر واحد:

x = y = z = 0
print(x)
print(y)
print(z)

الناتج سيكون:

0
0
0

في هذا المثال، عيّنّا المتغيرات الثلاثة (x و y و z) في نفس موقع الذاكرة. وكلها تساوي القيمة 0.

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

j, k, l = "shark", 2.05, 15
print(j)
print(k)
print(l)

وهذه هي المخرجات:

shark
2.05
15

في المثال أعلاه، أُسندَت السلسلة النصية "shark" إلى المتغير j، والعدد العشري 2.05 إلى المتغير k، والعدد الصحيح 15 إلى المتغير l.

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

المتغيرات العامة والمحلية

عند استخدام المتغيرات داخل البرنامج، من المهم أن تضع نطاق (scope) المتغير في حساباتك. يشير نطاق المتغير إلى المواضع التي يمكن الوصول منها إلى المتغير داخل الشيفرة، لأنَّه لا يمكن الوصول إلى جميع المتغيرات من جميع أجزاء البرنامج، فبعض المتغيرات عامة (global)، وبعضها محلي (local).

تُعرّف المتغيرات العامة خارج الدوال. أمَّا المتغيرات المحلية، فتوجد داخل الدوال.

المثال التالي يعطي فكرة عن المتغيرات العامة والمحلية:

# إنشاء متغير عام، خارج الدالة
glb_var = "global"



def var_function():
    lcl_var = "local"   # إنشاء متغير محلي داخل دالة
    print(lcl_var)

# استدعاء دالة لطباعة المتغير المحلي
var_function()

# طباعة متغير عام خارج دالة
print(glb_var)

المخرجات الناتجة:

local
global

يُسنِد البرنامج أعلاه سلسلة نصية إلى المتغير العمومي glb_var خارج الدالة، ثم يعرّف الدالة var_function()‎. وسيُنشِئ داخل تلك الدالة متغيِّرًا محليًّا باسم lcl_var، ثم يطبعه قيمته. ينتهي البرنامج باستدعاء الدالة var_function()‎، وطباعة قيمة المتغير glb_var.

لمَّا كان glb_var متغيرًا عامًّا، فيمكننا الوصول إليه داخل الدالة var_function()‎. المثال التالي يبيّن ذلك:

glb_var = "global"

def var_function():
    lcl_var = "local"
    print(lcl_var)
    print(glb_var) # داخل الدالة glb_var طباعة 

var_function()
print(glb_var)

المخرجات:

local
global
global

لقد طبعنا المتغير العام glb_var مرتين، حيث طُبع داخل الدالة وخارجها.

ماذا لو حاولنا استدعاء المتغير المحلي خارج الدالة؟

glb_var = "global"

def var_function():
    lcl_var = "local"
    print(lcl_var)

print(lcl_var)

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

NameError: name 'lcl_var' is not defined

دعنا ننظر إلى مثال آخر، حيث سنستخدم الاسم نفسه لمتغير عام وآخر محلي:

num1 = 5 # متغير عام

def my_function():
    num1 = 10 # num1 استخدام نفس اسم المتغير
    num2 = 7  # تعيين متغير محلي 

    print(num1) # num1 طباعة المتغير المحلي
    print(num2) # num2 طباعة المتغير المحلي

# my_function() استدعاء
my_function()

# num1 طباعة المتغير العام
print(num1)

الناتج:

10
7
5

نظرًا لأنّ المتغير المحلي num1 صُرِّح عنه محليًا داخل إحدى الدوال، فسنرى أنّ num1 يساوي القيمة المحلية 10 عند استدعاء الدالة. عندما نطبع القيمة العامة للمتغير num1 بعد استدعاء الدالة my_function()‎، سنرى أنّ المتغير العام num1 لا يزال مساويًا للقيمة 5.

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

def new_shark():
    # جعل المتغير عاما
    global shark
    shark = "Sammy"

# new_shark() استدعاء الدالة
new_shark()

# shark طباعة المتغير العام
print(shark)

رغم أنّ المتغير المحلي shark عُيِّن داخل الدالة new_shark()‎، إلا أنه يمكن الوصول إليه من خارج الدالة بسبب العبارة global المستخدمة قبل تعيين المتغير داخل الدالة.

بسبب استخدام العبارة global، فلن يُطلق أيّ خطأ عندما نستدعي print(shark)‎ خارج الدالة. رغم أنَّه يمكنك تعيين متغير عام داخل دالة، إلا أنّها من العادات غير المستحبة في البرمجة، لأنها قد تؤثر على مقروئية الشيفرة.

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

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

خلاصة

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

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

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