المتغيرات في بايثون: الاستخدام وأفضل الممارسات

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

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

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

التعرف على المتغيرات في بايثون

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

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

إنشاء المتغيرات باستخدام التعيينات

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

variable_name = value

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

وفيما يلي بعض الأمثلة على المتغيرات:

>>> word = "Python"

>>> number = 42

>>> coefficient = 2.87

>>> fruits = ["apple", "mango", "grape"]

>>> ordinals = {1: "first", 2: "second", 3: "third"}

>>> class SomeCustomClass: pass
>>> instance = SomeCustomClass()

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

تعيين نوع بيانات المتغير وتغييره

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

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

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

على سبيل المثال، ضع في اعتبارك المتغيرات التالية:

>>> name = "Jane Doe"
>>> age = 19
>>> subjects = ["Math", "English", "Physics", "Chemistry"]

>>> type(name)
<class 'str'>
>>> type(age)
<class 'int'>
>>> type(subjects)
<class 'list'>

في هذا المثال، يشير name  إلى قيمة "Jane Doe" ، لذا فإن نوع الاسم هو str. وبالمثل، يشير العمر إلى العدد الصحيح 19، لذا فإن نوعه هو int. وأخيرًا، يشير الكائن subject إلى قائمة، لذا فإن نوعه هو list. تجدر الإشارة إلى أنه ليس عليك تحديد نوع كل متغير بشكل صريح في بايثون. يحدد بايثون النوع ويضبطه بالتحقق من نوع القيمة المُخصصة.

نظرًا لأن بايثون مكتوب بشكل ديناميكي، فيمكنك جعل المتغيرات تشير إلى كائنات من أنواع بيانات مختلفة في لحظات مختلفة بمجرد إعادة تعيين المتغير:

>>> age = "19"
>>> type(age)
<class 'str'>

>>> subjects = {"Math", "English", "Physics", "Chemistry"}
>>> type(subjects)
<class 'set'>

الآن، يشير age إلى سلسلة نصية، وتشير subjects  إلى كائن مجموعة. بتعيين قيمة من نوع مختلف لمتغير موجود، يمكنك تغيير نوع المتغير.

العمل مع المتغيرات في بايثون

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

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

التعبيرات

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

>>> 2 * 3.1416 * 10
62.912
 
>>> 2 * 3.1416 * 20
125.824

يمثل كل تعبير من هذه التعبيرات عملية حسابية محددة. لبناء التعبيرات، استخدمت القيم ومعامل الضرب (*). يُقيّم بايثون كل تعبير ويُرجع القيمة الناتجة.

التعبيرات أعلاه جامدة نوعًا ما. لكل تعبير، عليك تكرار قيم الإدخال، وهي مهمة متكررة وعرضة للخطأ.

والآن فكر في الأمثلة التالية:

>>> pi = 3.1416
>>> radius = 10
 
>>> 2 * pi * radius
62.912
 
>>> radius = 20
>>> 2 * pi * radius
125.824

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

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

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

عدادات الكائنات

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

>>> str_counter = 0

>>> for item in ("Alice", 30, "Programmer", None, True, "Department C"):
...     if isinstance(item, str):
...          str_counter += 1
...

>>> str_counter
3

في هذا المثال، تُنشئ متغير str_counter بتهيئته إلى 0. ثم تُشغّل حلقة for على قائمة من الكائنات من أنواع مختلفة. داخل الحلقة، تتحقق مما إذا كان الكائن الحالي سلسلة نصية باستخدام الدالة المضمنة isinstance(). إذا كان الكائن الحالي سلسلة نصية، فتُزاد قيمة العداد بمقدار واحد.

في نهاية الحلقة، يكون لـ str_counter قيمة 3، وهو ما يعكس عدد كائنات السلسلة في قائمة الإدخال.

يمكنك إعادة استخدام التعبير str_counter += 1 في كل تكرار للحلقة لزيادة قيمة str_counter، مما يجعلها تتغير بمرور الوقت. يُعد هذا التحديث الديناميكي ميزة أساسية للمتغيرات. وكما يوحي اسمها، فهي مصممة لاحتواء قيم قابلة للتغير بمرور الوقت.

المتراكمات

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

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

>>> numbers = [1, 2, 3, 4]
>>> total = 0

>>> for number in numbers:
...     total += number
...

>>> total
10

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

>>> total / len(numbers)
2.5

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

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

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

>>> a = 5
>>> b = 10

>>> temp = a
>>> a = b
>>> b = temp

>>> a
10
>>> b
5

في هذا المثال، ستستخدم متغيرًا مؤقتًا يُسمى temp لحفظ قيمة a، مما يسمح لك بتبديل القيم بين a وb. بعد إتمام عملية التبديل، لن تحتاج إلى temp.

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

للحصول على مثال أكثر تفصيلاً لاستخدام المتغيرات المؤقتة، ضع في اعتبارك الدالة التالية التي تحسب تباين عينة من البيانات الرقمية:

>>> def variance(data, degrees_of_freedom=0):
...     return sum((x - sum(data) / len(data)) ** 2 for x in data) / (
...         len(data) - degrees_of_freedom
...     )
...
 
>>> variance([3, 4, 7, 5, 6, 2, 9, 4, 1, 3])
5.24

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

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

>>> def variance(data, degrees_of_freedom=0):
...     number_of_items = len(data)
...     mean = sum(data) / number_of_items
...     total_square_dev = sum((x - mean) ** 2 for x in data)
...     return total_square_dev / (number_of_items - degrees_of_freedom)
...
 
>>> variance([3, 4, 7, 5, 6, 2, 9, 4, 1, 3])
5.24

في هذا التطبيق البديل لدالة variance()، يمكنك حساب التباين على عدة خطوات. تُمثَّل كل خطوة بمتغير مؤقت يحمل اسمًا ذا معنى، مما يجعل الكود أسهل قراءة.

الأعلام المنطقية

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

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

>>> toggle = True
 
>>> for _ in range(4):
...     if toggle:
...         print(f"<img draggable="false" role="img" class="emoji" alt="✅" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/2705.svg"> toggle is {toggle}")
...         print("Do something...")
...     else:
...         print(f"<img draggable="false" role="img" class="emoji" alt="❌" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/274c.svg"> toggle is {toggle}")
...         print("Do something else...")
...     toggle = not toggle
...
<img draggable="false" role="img" class="emoji" alt="✅" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/2705.svg"> toggle is True
Do something...
<img draggable="false" role="img" class="emoji" alt="❌" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/274c.svg"> toggle is False
Do something else...
<img draggable="false" role="img" class="emoji" alt="✅" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/2705.svg"> toggle is True
Do something...
<img draggable="false" role="img" class="emoji" alt="❌" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/274c.svg"> toggle is False
Do something else...

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

تُستخدم الأعلام أيضًا كوسائط دالة. انظر إلى المثال التالي:

>>> def greet(name, verbose=False):
...     if verbose:
...         print(f"Hello, {name}! It's great to see you!")
...     else:
...         print(f"Hello, {name}!")
...
 
>>> greet("Pythonista")
Hello, Pythonista!
 
>>> greet("Pythonista", verbose=True)
Hello, Pythonista! It's great to see you!

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

ستجد أن بعض دوال بايثون المضمنة تستخدم وسيطات العلم. دالة sorted() مثال جيد على ذلك:

>>> sorted([4, 2, 7, 5, 1, 6, 3])
[1, 2, 3, 4, 5, 6, 7]
 
>>> sorted([4, 2, 7, 5, 1, 6, 3], reverse=True)
[7, 6, 5, 4, 3, 2, 1]

تأخذ الدالة sorted() عنصرًا قابلًا للتكرار كمُعامل، وتُرجع قائمةً بالكائنات المُرتّبة. تحتوي هذه الدالة على مُعامل عكسي، وهو علامة، ويكون افتراضيًا False. إذا عيّنت هذه المُعاملة إلى True، فسيتم ترتيب الكائنات بترتيب عكسي.

في الممارسة العملية، ستجد أن المتغيرات المنطقية غالبًا ما يتم تسميتها باستخدام نمط التسمية is_ أو has_:

>>> age = 20
 
>>> is_adult = age > 18
>>> is_adult
True

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

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

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

>>> colors = [
...     "red",
...     "orange",
...     "yellow",
...     "green",
...     "blue",
...     "indigo",
...     "violet"
... ]
 
>>> for color in colors:
...     print(color)
...
red
orange
yellow
green
blue
indigo
violet

في هذا المثال، ستُكرر قائمة ألوان باستخدام حلقة for. يحتفظ متغير الحلقة، color، باللون الحالي في كل تكرار. بهذه الطريقة، يمكنك تنفيذ بعض التعديلات على العنصر الحالي أثناء تكرار البيانات.

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

>>> for index, color in enumerate(colors):
...     print(index, color)
...
0 red
1 orange
2 yellow
3 green
4 blue
5 indigo
6 violet

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

يمكنك أيضًا استخدام المتغيرات للتحكم في حلقات while. إليك مثال بسيط:

>>> count = 5
 
>>> while count:
...     print(count)
...     count -= 1
...
5
4
3
2
1

في هذا المثال، يعمل متغير الحلقة كعداد يُحدد عدد التكرارات. داخل الحلقة، يُستخدم عامل الطرح المُعزَّز (-=) لتحديث قيمة المتغير.

متغيرات تخزين البيانات

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

>>> contacts = [
...     ("Linda", "111-2222-3333", "linda@example.com"),
...     ("Joe", "111-2222-3333", "joe@example.com"),
...     ("Lara", "111-2222-3333", "lara@example.com"),
...     ("David", "111-2222-3333", "david@example.com"),
...     ("Jane", "111-2222-3333", "jane@example.com"),
... ]

يتيح لك متغير contacts معالجة بياناتك باستخدام اسم واحد ووصفي. يمكنك استخدام المتغيرات في حلقة، على سبيل المثال:

>>> for contact in contacts:
...     print(contact)
...
('Linda', '111-2222-3333', 'linda@example.com')
('Joe', '111-2222-3333', 'joe@example.com')
('Lara', '111-2222-3333', 'lara@example.com')
('David', '111-2222-3333', 'david@example.com')
('Jane', '111-2222-3333', 'jane@example.com')
 
>>> for name, phone, email in contacts:
...     print(phone, name)
...
111-2222-3333 Linda
111-2222-3333 Joe
111-2222-3333 Lara
111-2222-3333 David
111-2222-3333 Jane

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

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

لذا، يمكنك إعادة كتابة رأس الحلقة ليصبح هكذا: name، وphone، _ in contacts:. في هذه الحالة، تُمثل الشرطة السفلية متغير البريد الإلكتروني، والذي لا تستخدمه في نص الحلقة.

تسمية المتغيرات في بايثون

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

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

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

يمكن أن تكون أسماء المتغيرات في بايثون بأي طول، ويمكن أن تتكون من أحرف كبيرة (A-Z) وأحرف صغيرة (a-z)، وأرقام (0-9)، وعلامة السفل (_). القيد الوحيد هو أنه على الرغم من إمكانية احتواء اسم المتغير على أرقام، لا يمكن أن يكون الحرف الأول منه رقمًا.

ملاحظة: يدعم بايثون حاليًا أحرف Unicode بالكامل، ويمكنك استخدام العديد من أحرف Unicode في أسماء المتغيرات.

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

كل ما يلي هو أسماء متغيرات صالحة:

>>> name = "Bob"
>>> year_of_birth = 1970
>>> is_adult = True

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

اسم المتغير أدناه لا يتبع القواعد:

>>> 1099_filed = False
  File "<input>", line 1
    1099_filed = False
        ^
SyntaxError: invalid decimal literal

يبدأ اسم المتغير في هذا المثال برقم، وهو غير مسموح به في بايثون. لذلك، ستحصل على استثناء SyntaxError.

من المهم معرفة أن المتغيرات حساسة لحالة الأحرف. لا تُعامل الأحرف الصغيرة والكبيرة بنفس الطريقة:

>>> age = 1
>>> Age = 2
>>> aGe = 3
>>> AGE = 4

>>> age
1
>>> Age
2
>>> aGe
3
>>> AGE
4

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

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

استخدام الشرطة السفلية مهم أيضًا. ستستخدمها لفصل عدة كلمات في اسم متغير:

>>> first_name = "John"
>>> pen_color = "red"
>>> next_node = 123

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

>>> firstname = "John"
>>> pencolor = "red"
>>> nextnode = 123

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

أفضل الممارسات لتسمية المتغيرات

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

>>> temperature = 25
>>> weight = 54.5
>>> message = "Hello, Pythonista!"

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

بشكل عام، يجب عليك تجنب الأسماء المكونة من حرف واحد:

>>> t = 25  # Don't do this
>>> temperature = 25  # Do this instead

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

>>> matrix = [
...     [9, 3, 8],
...     [4, 5, 2],
...     [6, 4, 3],
... ]

>>> for i in matrix:
...     for j in i:
...         print(j)
...
9
3
8
4
5
2
6
4
3

من الشائع استخدام أحرف مثل i وj وk لتمثيل المؤشرات، مما يتيح استخدامها في السياق المناسب. كما يشيع استخدام x وy وz لتمثيل إحداثيات النقاط، لذا لا بأس باستخدامها.

لا ينصح باستخدام الاختصارات لتسمية المتغيرات، ويفضل استخدام الاسم الكامل:

>>> doc = "Freud"  # Don't do this
>>> doctor = "Freud"  # Do this instead

يُفضّل استخدام اسم كامل بدلاً من اسم مُختصر، فهو أسهل قراءةً ووضوحًا. مع ذلك، قد تكون الاختصارات مقبولة أحيانًا عندما تكون شائعة الاستخدام:

>>> cmd = "python -m pip list"
>>> msg = "Hello, Pythonista!"

في هذه الأمثلة، يُستخدم cmd اختصارًا شائعًا لكلمة command، ويُستخدم msg اختصارًا لكلمة message. ومن الأمثلة الشائعة على الاختصارات الشائعة في بايثون اسم cls، والذي يُستخدم لتحديد كائن الفئة الحالي في دالة الفئة.

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

>>> numberofgraduates = 200

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

الممارسات الأكثر شيوعًا لأسماء المتغيرات المكونة من عدة كلمات هي التالية:

• حالة الثعبان: تُفصل الكلمات الصغيرة بعلامة سفلية. على سبيل المثال: number_of_graduates.
• حالة الجمل: تُكتب الكلمة الثانية وما يليها بأحرف كبيرة لتسهيل رؤية حدود الكلمات. على سبيل المثال: numberOfGraduates.
• باسكال: شبيهة بجملة الجمل، إلا أن الكلمة الأولى تُكتب بحرف كبير. مثال: NumberOfGraduates.

يحتوي دليل أسلوب كود بايثون، المعروف أيضًا باسم PEP 8، على قواعد تسمية تسرد معايير مقترحة لأسماء أنواع الكائنات المختلفة. فيما يتعلق بالمتغيرات، يوصي PEP 8 باستخدام أسلوب “الثعبان.

عندما تحتاج إلى أسماء مكونة من عدة كلمات، فمن الشائع الجمع بين صفة كمؤهل واسم:

>>> initial_temperature = 25
>>> current_file = "marketing_personel.csv"
>>> next_point = (2, 4)

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

متغيرات العلم هي مثال جيد آخر على متى يجب استخدام اسم متغير متعدد الكلمات:

>>> is_authenticated = True
>>> has_permission = False

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

عندما يتعلق الأمر بتسمية القوائم والقواميس، يجب عليك استخدام الأسماء الجمع في معظم المواقف:

>>> fruits = ["apple", "banana", "cherry"]

>>> colors = {
...     "Red": (255, 0, 0),
...     "Green": (0, 255, 0),
...     "Blue": (0, 0, 255),
...     "Yellow": (255, 255, 0),
...     "Black": (0, 0, 0),
...     "White": (255, 255, 255),
... }

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

عند تسمية المجموعات، يجب مراعاة أنها تُستخدم عادةً لتخزين كائنات ذات أنواع أو معانٍ مختلفة. لذا، لا بأس باستخدام الأسماء المفردة:

>>> color = (255, 0, 0)
>>> row = ("Jane", 25, "Python Dev", "Canada")

على الرغم من أن هذه المجموعات تخزن كائنات متعددة، إلا أنها تُمثل كيانًا واحدًا. يُمثل المجموعة الأولى لون RGB (أحمر، أخضر، أزرق)، بينما تُمثل المجموعة الثانية صفًا في جدول قاعدة بيانات أو أي بيانات جدولية أخرى.

أسماء المتغيرات العامة وغير العامة

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

_timeout = 30

def get_timeout():
    return _timeout

def set_timeout(seconds):
    global _timeout
    _timeout = seconds

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

الأسماء المقيدة والمحظورة

تحتفظ بايثون بمجموعة صغيرة من الكلمات تُعرف بالكلمات المفتاحية، وهي جزء من تركيبها النحوي. للحصول على قائمة كلمات بايثون المفتاحية، شغّل الكود التالي:

>>> import keyword
>>> keyword.kwlist
[
    'False',
    'None',
    'True',
    'and',
    'as',
    'assert',
    'async',
    ...,
    'yield'
]

في معظم الحالات، لن تتمكن من استخدام هذه الكلمات كأسماء متغيرات دون الحصول على خطأ:

>>> class = "Business"
  File "<input>", line 1
    class = "Business"
          ^
SyntaxError: invalid syntax

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

>>> class_ = "Business"

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

>>> passenger_class = "Business"

الآن، أصبح اسم المتغير الخاص بك أكثر وصفًا وتحديدًا، مما يحسن قابلية قراءة الكود الخاص بك.

هناك أيضًا كلمات مفتاحية مرنة، وهي كلمات مفتاحية تُستخدم فقط في سياقات محددة. على سبيل المثال، تُعتبر كلمة “المطابقة” كلمة مفتاحية فقط في مطابقة الأنماط الهيكلية.

نظرًا لأن match عبارة عن كلمة أساسية ناعمة، فيمكنك استخدامها لتسمية المتغيرات:

>>> import re
 
>>> text = "Some text containing a number: 123"
>>> match = re.search("123", text)
 
>>> if match:
...     print("Found a match <img draggable="false" role="img" class="emoji" alt="😃" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/1f603.svg">")
... else:
...     print("No match found <img draggable="false" role="img" class="emoji" alt="😔" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/1f614.svg">")
...
Found a match <img draggable="false" role="img" class="emoji" alt="😃" src="https://s0.wp.com/wp-content/mu-plugins/wpcom-smileys/twemoji/2/svg/1f603.svg">

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

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

>>> list = [1, 2, 3, 4]
>>> list
[1, 2, 3, 4]

في هذا المثال، استخدمتَ list كاسم لكائن قائمة يحتوي على قيم رقمية. هذا يُخفي الكائن الأصلي خلف الاسم، مما يمنعك من استخدامه في الكود.

>>> list(range(10))
Traceback (most recent call last):
    ...
TypeError: 'list' object is not callable

الآن، يفشل استدعاء list() لأنك تجاوزت الاسم المُضمّن في الكود. لذا، يُفضّل تجنب الأسماء المُضمّنة لتعريف متغيراتك. قد تُؤدي هذه الممارسة إلى فشل الكود بطرق مُختلفة.

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

استكشاف الميزات الأساسية للمتغيرات

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

المتغيرات تحتوي على مراجع للكائنات

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

بايثون لغة برمجة كائنية التوجه. كل جزء من البيانات في برنامج بايثون هو كائن من نوع أو فئة محددة. انظر إلى هذا الكود:

>>> 300
300

عند تقديم العبارة 300، يقوم بايثون بالعمليات التالية:

• يُنشئ كائنًا صحيحًا
• يُعطيه قيمة 300
• يعرضه على الشاشة

يمكنك أن ترى أن كائن عدد صحيح تم إنشاؤه باستخدام الدالة type() المضمنة:

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

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

على سبيل المثال، ضع في اعتبارك تعريف المتغير التالي:

>>> n = 300

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

في بايثون، لا تخزن المتغيرات الكائنات، بل تشير إليها. في كل مرة تُنشئ فيها كائنًا في بايثون، يُخصص له رقم فريد، يُربط بعد ذلك بالمتغير.

تعيد الدالة المضمنة id() معرف الكائن أو هويته:

>>> n = 300
>>> id(n)
4399012816

في توزيعة بايثون القياسية (CPython)، تتطابق هوية الكائن مع عنوان ذاكرته. لذلك، تخزن متغيرات CPython عناوين الذاكرة. ومن خلال هذه العناوين، تصل المتغيرات إلى الكائنات المُخزنة في الذاكرة.

يمكنك إنشاء متغيرات متعددة تشير إلى نفس الكائن. بمعنى آخر، متغيرات تحمل نفس عنوان الذاكرة:

>>> m = n
>>> id(n) == id(m)
True

في هذا المثال، لا يُنشئ بايثون كائنًا جديدًا، بل يُنشئ اسمًا أو مرجعًا لمتغير جديد، m، يُشير إلى نفس الكائن الذي يُشير إليه n:

بعد ذلك، افترض أنك تفعل شيئًا كهذا:

>>> m = 400

الآن، يقوم Python بإنشاء كائن عدد صحيح جديد بقيمة 400، ويصبح m مرجعًا له:

وأخيرًا، لنفترض أنك قمت بتشغيل العبارة التالية:

>>> n = "foo"الآن، يقوم Python بإنشاء كائن سلسلة بقيمة “foo” ويجعل n مرجعًا لذلك.

بسبب إعادة تعيين n وm، لم يعد لديك مرجع لكائن العدد الصحيح 300. لقد أصبح يتيمًا، وليس لديك طريقة للوصول إليه مرة أخرى.

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

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

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

>>> value = "A string value"
>>> value
'A string value'
 
>>> # Later
>>> value = 23.5
>>> value
23.5

في هذا المثال، ستجعل متغير value يشير إلى كائن من نوع آخر. بفضل هذه الميزة، تُعدّ بايثون لغةً ذات كتابة ديناميكية.

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

>>> value = "A string value"
>>> value.upper()
'A STRING VALUE'
 
>>> # Later
>>> value = 23.5
 
>>> # Try to use .upper() again
>>> value.upper()
Traceback (most recent call last):
    ...
AttributeError: 'float' object has no attribute 'upper'

في هذا المثال، يتغير نوع المتغير أثناء تنفيذ الكود. عندما تشير value إلى سلسلة نصية، يمكنك استخدام دالة upper() لتحويل الأحرف إلى أحرف كبيرة. ولكن، عندما يتغير النوع إلى عدد عشري، لا تتوفر دالة upper()، ويحدث استثناء AttributeError.

استخدام الطرق التكميلية لإنشاء المتغيرات

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

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

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

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

التعيين الموازي

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

>>> is_authenticated = is_active = is_admin = False
 
>>> is_authenticated
False
>>> is_active
False
>>> is_admin
False

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

>>> is_authenticated = False
>>> is_active = False
>>> is_admin = False
 
>>> is_authenticated
False
>>> is_active
False
>>> is_admin
False

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

تفريغ قابل للتكرار

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

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

>>> person = ("Jane", 25, "Python Dev")

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

>>> name = person[0]
>>> age = person[1]
>>> job = person[2]
 
>>> name
'Jane'
>>> age
25
>>> job
'Python Dev'

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

>>> name, age, job = person
 
>>> name
'Jane'
>>> age
25
>>> job
'Python Dev'

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

حالة استخدام رائعة لفك الضغط هي عندما تحتاج إلى تبديل القيم بين متغيرين:

>>> a = 5
>>> b = 10
 
>>> a, b = b, a
 
>>> a
10
>>> b
5

في السطر الثالث، تُبدّل قيمتي a وb دون استخدام مُتغيّر مؤقت، كما رأينا سابقًا. في هذا المثال، من المهم ملاحظة أن المُتغيّر القابل للتكرار على يمين علامة التساوي هو مجموعة من المُتغيّرات.

تعبيرات التعيين

تتيح لك تعبيرات التعيين تعيين نتيجة تعبير مستخدم في حلقة شرطية أو حلقة while إلى اسم في خطوة واحدة. على سبيل المثال، لننظر إلى الحلقة التالية التي تستقبل الإدخالات من لوحة المفاتيح حتى تكتب كلمة “stop”:

>>> line = input("Type some text: ")

>>> while line != "stop":
...     print(line)
...     line = input("Type some text: ")
...
Type some text: Python
Python
Type some text: Walrus
Walrus
Type some text: stop

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

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

>>> while (line := input("Type some text: ")) != "stop":
...     print(line)
...
Type some text: Python
Python
Type some text: Walrus
Walrus
Type some text: stop

في التعبير (line := input("Type some text: "))، أنشئ متغيرًا جديدًا باسم line للاحتفاظ بإشارة إلى بيانات الإدخال. تُرجع هذه البيانات أيضًا كنتيجة للتعبير، والتي تُقارن في النهاية بكلمة “stop” لإنهاء الحلقة. لذا، تُعد تعبيرات التعيين طريقة أخرى لإنشاء المتغيرات.

فهم نطاقات المتغيرات

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

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

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

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

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

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

>>> value = 42
>>> dir()
[
    '__builtins__',
    '__doc__',
    '__loader__',
    '__name__',
    ...
    'value'
]

في هذا المقطع البرمجي، تُعرّف متغير value وتُستدعي الدالة المُدمجة dir() للتحقق من قائمة الأسماء المُعرّفة في نطاقك العالمي الحالي. في نهاية القائمة، ستجد مُدخل “value“، المُطابق لمتغيرك.

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

>>> value
42

ستلاحظ أن المتغيرات ستظل متاحة لك، لأن قيمة هذا المتغير عالمية بالنسبة لكودك.

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

كمثال سريع، لنفترض أن لديك وحدة config.py التالية:

settings = {
    "background": "black",
    "foreground": "white",
    "logo": "logo.png",
    "font": "Helvetica",
}

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

>>> from config import settings

>>> settings["background"]
'black'
>>> settings["font"]
'Helvetica'

باستخدام الاستيراد في السطر الأول، تكون قد جلبت متغير settings  إلى نطاقك العالمي الحالي. يمكنك استخدام المتغير من أي جزء من الكود.

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

خذ بعين الاعتبار المثال التالي:

>>> def function():
...     integer = 42
...     return integer
...

>>> function()
42

>>> integer
Traceback (most recent call last):
    ...
NameError: name 'integer' is not defined

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

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

# Global scope
global_variable = "global"

def outer_func():
    # Nonlocal scope
    nonlocal_variable = "nonlocal"
    def inner_func():
        # Local scope
        local_variable = "local"
        print(f"Hi from the '{local_variable}' scope!")
        print(f"Hi from the '{nonlocal_variable}' scope!")
        print(f"Hi from the '{global_variable}' scope!")
    inner_func()

في هذا المثال، تُنشئ أولاً متغيرًا عامًا على مستوى الوحدة. ثم تُعرّف دالة تُسمى external_func(). داخل هذه الدالة، يوجد متغير nonlocal_variable، وهو محلي لـ external_func() وغير محلي لـ inner_func().

في inner_func()، يمكنك إنشاء متغير آخر يسمى local_variable، وهو محلي للدالة نفسها.

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

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

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

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