برمجة الذكاء الاصطناعي أنواع البيانات والعمليات الأساسية في لغة بايثون

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

المتغيرات

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

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

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

x = 10; print(x)
y = 10.5; print(y)
z = "Word"; print(z)

عرَّفنا تلك المتغيرات في المثال السابق وأسندنا لها قيمة مباشرةً لتحجز بايثون لتلك المتغيرات مساحة في ذاكرة الحاسوب، أولها المتغير x من نوع بيانات الأعداد الصحيحة Integer، وثانيها المتغير y من نوع بيانات الأعداد العشرية Float؛ أما ثالثها فهو المتغير z من نوع نص أو سلسلة نصية String، وعلى الرغم من اختلاف أنواع تلك المتغيرات، إلا أننا لم نحدِّد تلك الأنواع مسبقًا، فقد عيّنا البيانات في المتغير فقط بعد تحديد اسم المتغير مباشرةً، ويمكن تغيير نوع البيانات في المتغير ببساطة وبدون أدنى مشكلة، وذلك ليس هو الحال في كل اللغات.

x = 10; print(x)
x = "word"; print(x)

فعند تعريف متغير جديد في كثير من لغات البرمجة، يلتزم المبرمِج بتعريف نوع البيانات التي ستُخزَّن في المتغير، وبناءً على ذلك تحدِّد اللغة مكانًا له في الذاكرة ولا يمكنك عادةً في تلك اللغات تغيير نوع البيانات التي قيدت بها المتغير لأن اللغة تفحص المتغير ونوعه أثناء تنفيذ كامل الشيفرة، فإذا عرَّفت متغير ما على سبيل المثال وحدَّدت نوع البيانات بأنه عدد عشري، فلا يمكن بعد ذلك تخزين نص في ذلك المتغير -أي في ذلك المكان في الذاكرة- وذلك النوع من اللغات يُطلق عليه لقب Statically Typed مثل Fortran و Java وC؛ أما بايثون فتُعَدّ من اللغات الديناميكية، أي لا تتطلب تحديد نوع المتغير صراحةً، إذ يستطيع المتغير حواية أيّ نوع من أنواع البيانات وتغييرها لاحقًا، ولمزيد من التفاصيل حول هذه النقطة، ارجع إلى مقال لغات البرمجة قسم أنواع لغات البرمجة.

ومن ديناميكية لغة بايثون وجود إمكانية تعريف وتعيين قيمة لعدة متغيرات في التعليمة نفسها، ففي المثال التالي نسند رقم إلى ثلاثة متغيرات في الوقت نفسه.

x = y = z = 1

سيُطبَع الرقم 1 عند طباعة أيّ متغير من تلك المتغيرات لأنها تحمل البيانات نفسها، كما أنه من الممكن تعريف أكثر من متغير وتعيين بيانات مختلفة من أنواع متطابقة أو مختلفة لكل متغير في السطر نفسه كما في المثال التالي:

x, y, z = 10, "Hello", "World"
print(x)
print(y)
print(z)
>> 10
>> Hello
>> World

حذف المتغيرات

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

x = 1
print (x)
del x

أنواع البيانات في لغة بايثون

تختلف أنواع البيانات التي تدعمها لغة بايثون، حيث تدعم البيانات النصية، وهي البيانات التي تحتوي على أحرف ونصوص Strings، والبيانات العددية سواءً كانت أعدادًا صحيحةً Integers أو أعدادًا عشرية Floats، أو أعدادًا عقدية Complex Numbers، كما توجد أنواع أخرى مثل الصفوف Tuples والقواميس Dictionaries والقوائم Lists.

النصوص Strings

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

يمكن التعامل مع المتغيرات النصية في بايثون على أساس مصفوفة ذات بُعد واحد، إذ يمثِّل كل حرف قيمةً بذاتها داخل المصفوفة، فيمكن التفكير في النص التالي Hello World!‎ على أنه مصفوفة يُربَط كل حرف أو مسافة فيه بعدد، بحيث يبدأ الترقيم في المصفوفات وغيرها من أنواع البيانات المشابهة في معظم لغات البرمجة بالرقم صفر وليس واحد، أي كما يلي:

يمكننا طباعة المحرف بناءً على الجدول بكتابة اسم المتغير الذي يحتوي على النص ثم كتابة رقمه بين علامَتي الأقواس المعقوفة []، فلطباعة المحرف r مثلًا نستخدِم الرقم 8، ولطباعة المحرف H من النص السابق يمكن ذلك كما في الشيفرة التالية:

x = "Hello World!"
print(x[0])
>> H

يمكن الطباعة من محرف إلى آخر عن طريق كتابة رمز : بين رقم محرف البداية وعدد المحارف المطلوبة، فلطباعة كلمة Hello مثلًا، فسنبدأ بصفر ثم نعُد خمسة محارف من H إلى O، ولذلك نستطيع طباعة الكلمة عبر الشيفرة الآتي:

x = "Hello World!"
print (x[0:5])
>> Hello

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

x = "Hello World!"
print (x[0:])
>> Hello World!
print (x[6:])
>> World!

يمكن أيضًا طباعة النص مرتين باستخدام علامة الضرب الرياضية.

x = "Hello World! "
print (x * 2)
>> Hello World! Hello World!

القوائم Lists

تتوفر في بايثون ما يُدعى بالقوائم Lists، وهي تشبه إلى حد كبير المصفوفات في لغات البرمجة الأخرى، فببساطة يمكن تعريف القائمة في بايثون بأنها متغير يحتوي على مصفوفة من البيانات والتي من الممكن أن تكون من أنواع مختلفة، كما من الممكن التعامل معها كما أوردنا في التعامل مع النصوص على أساس مصفوفة، إذ تُعيَّن قيمة متغير القائمة عبر كتابة القيم بصورة متتابعة يليها فاصلة , بين الأقواس المعقوفة []، وإليك المثال التالي:

x = ['abc', 'efg', 100, 'ilm', 10.54]
print (x[0])
>> abc
print (x)
>> ['abc', 'efg', 100, 'ilm', 10.54]
print (x[1:3])
>> ['efg', 100]
print (x[1:])
>> ['efg', 100, 'ilm', 10.54]
print (x * 2)
>> ['abc', 'efg', 100, 'ilm', 10.54, 'abc', 'efg', 100, 'ilm', 10.54]
y = ['xyz']
print (x + y)
>> ['abc', 'efg', 100, 'ilm', 10.54, 'xyz']

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

الصفوف Tuples

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

x = ('abc', 'efg', 100, 'ilm', 10.54)
print (x[0])
>> abc
print (x)
>> ('abc', 'efg', 100, 'ilm', 10.54)
print (x[1:3])
>> ('efg', 100)
print (x[1:])
>> ('efg', 100, 'ilm', 10.54)
print (x * 2)
>> ('abc', 'efg', 100, 'ilm', 10.54, 'abc', 'efg', 100, 'ilm', 10.54)
y = ('xyz', 'abc')
print (x + y)
>> ('abc', 'efg', 100, 'ilm', 10.54, 'xyz', 'abc')

توجد اختلافات بين القوائم والصفوف نلخصها في النقطتين الآتيتين.

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

ثانيًا، لا يمكن تغيير قيمة عنصر من عناصر الصفوف، في حين يمكن تغيير قيمة عنصر من عناصر القوائم كما يلي:

x = ['hello', 'world']
x[1] = 'there'
print (x)
>> ['hello', 'there']

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

TypeError: 'tuple' object does not support item assignment.

ما يعني أنّ الصفوف لا تدعم تعيين قيم للعناصر.

القواميس Dictionary

يشبه القاموس Dictionary في بايثون جدول Hash أي Hash-table وهو إحدى هياكل البيانات في علوم الحاسوب بحيث تُربَط القيم بمفتاح ومن ثم البحث عن القيم بسرعة كبيرة إذ أنها تعمل على أساس مصفوفة تحتوي على أزواج من المفاتيح والقيم، بحيث يوجد مفتاح ما لكل قيمة يتيح الوصول إليها، وتُعرَّف القواميس عبر الأقواس المعقوصة { }، كما أنّ القواميس بدورها غير مرتبة، بعكس الصفوف والقوائم التي تُرتَّب فيها مفاتيح كل عنصر بالترتيب الرقمي بدءًا من الصفر أي يعيِّن المبرمج مفاتيح القواميس والتي من الممكن أن تكون نصيةً أو عدديةً بدون ترتيب.

x = {'key': 'value', '2ndKey': '2ndValue'}
print (x['key'])
>> 'value'

يمكن للمفاتيح أن تكون نصيةً أو عددية مثل الصفوف والقوائم، أي كما يلي:

x = {'key': 'value', 2: '2ndValue'}
print (x[2])
>> '2ndValue'

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

x = {'key': 'value', 2: '2ndValue'}
x['key'] = "Hello"
print (x)
>> {'key': 'Hello', 2: '2ndValue'}

ويمكن استخلاص مفاتيح القاموس أو قيمه عبر التوابع keys وvalues كما يلي:

x = {'key': 'value', 2: '2ndValue'}
print (x.keys())
>> dict_keys(['key', 2])
print (x.values())
>> dict_values(['value', '2ndValue'])

المجموعات Sets

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

names = {'Adam', 'Noah'}
print (names)

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

تحويل أنواع البيانات في لغة بايثون

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

x = '2'

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

print (type(x))
>> <class 'str'>

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

x * 2
>> '22'
x + '4'
>> '24'

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

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

التحويل إلى عدد صحيح int

يمكن تحويل البيانات مثل النصوص إلى رقم صحيح باستخدام الدالة int التي هي اختصار لكلمة Integer، أي عدد صحيح، ففي المثال الآتي حوِّل المتغير النصي x إلى عدد صحيح، كما يمكن تنفيذ عمليات حسابية عليه.

x = '2'
x = int(x)
print (type(x))
>> <class 'int'>
print (x * 2)
>> 4

التحويل إلى عدد عشري float

يمكن تحويل البيانات مثل النصوص إلى عدد عشري باستخدام الدالة float، ففي المثال حوِّل نص إلى عدد عشري، كما يمكن تنفيذ عمليات حسابية عليه.

x = '2.5'
x = float(x)
print (type(x))
>> <class 'float'>
print (x * 2)
>> 5.0

التحويل إلى نص str

يمكن تحويل البيانات مثل الأعداد الصحيحة والعشرية إلى نصوص عبر الدالة str، ففي المثال التالي حُوِّل عدد عشري إلى نص.

x = 1.5
x = str(x)
print (type(x))
>> <class 'str'>

التحويل إلى صف Tuple

يمكن تحويل بعض أنواع البيانات لتكون صفًا Tuple باستخدام الدالة tuple، ومن تلك الأنواع النصوص والقواميس والقوائم، ولكن لا يمكن تحويل الأعداد إلى صفوف.

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

x = '1'; x = tuple(x); print (x)
>> ('1',)

التحويل إلى قائمة List

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

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

نُحوِّل في المثال الآتي نص إلى قائمة، ومن ثم نطبعه.

x = 'Hello'; x = list(x); print(x)
>> ['H', 'e', 'l', 'l', 'o']

التحويل إلى قاموس Dictionary

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

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

x = 'value'; y = {'key': x, 'a': 'b'}; print (y)
>> {'key': 'value', 'a': 'b'}
z = dict(key = x, a = 'b'); print (z)
>> {'key': 'value', 'a': 'b'}

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

تتوفر في بايثون وفي العديد من لغات البرمجة الأخرى العديد من العوامل المفيدة التي تساعدنا على إجراء مختلف العمليات مثل العمليات الرياضية والحسابية أو عمليات التعريف والإسناد وسمي عامل من عوامل لأنه يجري عملية على عدة مُعامَلات تُستخدم معه مثل عملية الجمع 5+5 تسمى الإشارة + بعامل والعدد 5 بالمُعامَل.

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

العوامل الرياضية أو الحسابية Arithmetic Operators

تهدف العوامل الحسابية من اسمها إلى تنفيذ العمليات الحسابية من خلال شيفرة بايثون، فعلامات الجمع + والطرح - والقسمة / والضرب * كلها من العوامل الحسابية، ونذكر أيضًا عامل باقي القسمة وهو علامة النسبة المئوية %، وقد أوردتُ أمثلةً على جميع تلك العوامل في بداية المقال.

نضيف إلى تلك العوامل عاملَين آخرين هما العامل الأسي Exponent Operator وعامل القسمة الصحيحة Floor Division.

أما العامل الأسي ** فيقوم بعملية ضرب أُسي على الأرقام، فمثلًا 5 أُس 4 تعني ضرب الرقم 5 في نفسه 4 مرات، وينتج ذلك الرقم 625. أما مهمة عامل القسمة الصحيحة //، هي عملية القسمة العادية مع إنتاج الرقم الصحيح فقط من الناتج دونًا عن الأرقام والكسور العشرية، فمثلًا ناتج قسمة 26 على 5 هو 5.2، لكن في القسمة الصحيحة ينتج ذلك الرقم 5 فقط ويتم حذف 0.2 من الناتج.

x = 5
print (x ** 4)
>> 625
y = 26
print (y // 5)
>> 5

معوامل الموازنة Comparison Operators

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

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

x = 1; y = 1
print (x == y)
>> True
print (x != y)
>> False

المعوامل المنطقية Logical Operators

تُستخدَم العوامل المنطقية لتركيب أسئلة منطقية أكثر تعقيدًا من خلال عوامل الموازنة السابق ذكرها مثلًا، فبافتراض وجود أربعة متغيرات وهي x و y و z و v، وإذا سألنا السؤال التالي: هل قيمة المتغير x تساوي قيمة المتغير y أو قيمة المتغير z تساوي قيمة المتغير v؟

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

توجد ثلاثة عوامل منطقية هي AND و OR و NOT بصورة أساسية، وكل منها يتعامل مع الجمل بطرق مختلفة، فالعامل الأول والثاني يعالجان أسئلةً معقدةً تتكون من أكثر من سؤال فرعي؛ أما الثالث فيتعامل مع جملة محدَّدة بحيث ينفي نتيجتها المنطقية أي يُحوِّل الصح True إلى خطأ False.

وفيما يلي استخدامات العوامل المنطقية:

• And: إذا كانت جميع الجمل أو الأسئلة الفرعية صحيحةً، فستنتُج إجابة صحيحة True، وإذا كانت أيّ من الأسئلة الفرعية خاطئةً، فسينتُج خطأ False.

x = 1;  y = 1
x == 1  and y == 1 # >> True

• or: إذا كانت أي من الجمل صحيحةً، فستنتُج إجابة صحيحة حتى إذا كانت باقي الجمل غير صحيحة

x = 1;  y =1
x == 2  or y == 1 # >> True

• Not: يعكس القيمة المنطقية الناتجة.

x = 1
not x == 1  # >> False

عوامل العضوية Membership Operators

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

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

x = [5, 6, 7]
print (5 in x)
>> True
y = (5, 6, 7)
print (5 in y)
>> True
z = {5: 'x', 6: 'y', 7: 'z'}
print (5 in z)
>> True

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

x = [5, 6, 7]
print (5 not in x)
>> False
y = (5, 6, 7)
print (5 not in y)
>> False
z = {5: 'x', 6: 'y', 7: 'z'}
print (5 not in z)
>> False

عوامل الهوية Identity Operators

وهي إحدى الأنواع المستخدَمة في الموازنة، إذ توازن بين شيئين للتحقق من تطابقهما تمامًا، ويوجد عاملان فقط تحت هذا التصنيف وهما عامل is وعامل نفيه is not، إذ يستخدَم العامل الأول للتحقق من تطابق كائنين؛ أما الثاني فيستخدَم للتحقق من عدم تطابق كائنين، وفيما يلي مثال على ذلك:

x = 5
print (x is 5)
>> True
print (x is not 5)
>> False

عوامل الإسناد Assignment Operators

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

x = 1
x = x + 1

print (x)
>> 2

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

x = 1
x += 1
print (x)
>> 2

نذكر في الجدول التالي تلك العوامل مع استخداماتها:

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

اقرأ أيضًا

• المقال السابق: أساسيات البرمجة بلغة بايثون
• أنواع البيانات
• التعامل مع الصفوف، المجموعات والقواميس في بايثون
• فهم أنواع البيانات في بايثون 3