دورة Python للمبتدئين

9 : البرمجة بلغة بايثون – Tuples، Dictionaries و Sets

Python3.8

السلام عليكم و رحمة الله وبركاته

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

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

القواميس Dictionaries

تجمع القواميس مجموعة من البيانات أيضا، و لكن هذه البيانات غير مُعلمة أو مفهرسة بأرقام كما في القوائم lists و المصفوفات tuples، فالقواميس مفهرسة بمفاتيح keys.

هذه المفاتيح يمكن أن تكون أي نوع من الأنواع الغير القابلة للتغيير immutable كالنصوص string و الأرقام، و أيضا المصفوفات Tuples التي تحتوي فقط على نصوص و/أو أرقام أو مصفوفات أخرى بشرط ألا تحتوي بدورها على أنواع قابلة للتغيير.

ملاحظة: لا يمكن استعمال القوائم lists كمفاتيح في القواميس لأنها قابلة للتعديل و التغيير.

قواعد إنشاء القواميس

يتم جمع البيانات على شكل زوج key:value أي مفتاح:قيمة داخل اللامتين {}، بحيث لا يجب أن يتكرر مفتاح ما مرتين.

  • يمكن إنشاء قاموس بالطريقة التالية:
>>> dictionary_name = { key: value, key: value }

مثال:

>>> d = {'One': 1, 'Two': 2, 'Three': 3}
>>> d
{'One': 1, 'Two': 2, 'Three': 3}
  • طلب إظهار قيمة معينة بواسطة المفتاح:
>>> d['One']
1

عندما نطلب القيمة ذات المفتاح ‘One’، يظهر الرقم 1. ماذا لو قمنا بالعكس و طلبنا المفتاح الخاص بالقيمة 2 مثلا؟

>>> d[2]
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    d[2]
KeyError: 2

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

>>> d2 = {'One':1, 'Un': 1, 'Two': 2, 'Deux': 2}
>>> d2
{'One': 1, 'Un': 1, 'Two': 2, 'Deux': 2}
>>> d2['Un']
1
>>> d2['One']
1

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

>>> d3 = {'One':1, 'One': 2, 'Two' : 2}
>>> d3
{'One': 2, 'Two': 2}
>>> d3 = {1: 'Hello', 1:'World'}
>>> d3
{1: 'World'}
  • يمكن حذف زوج ما باستعمال del بالطريقة التالية:
>>> d
{'One': 1, 'Two': 2, 'Three': 3}
>>> del d['One']
>>> d
{'Two': 2, 'Three': 3}
  • يمكن إضافة زوج ما بالطريقة التالية:
>>> d['Four'] = 4
>>> d
{'Two': 2, 'Three': 3, 'Four': 4}
  • يمكن إنشاء قواميس بواسطة الدالة dict :
>>> a = dict([('Python',1), ('is',2), ('fun',3)])
>>> a
{'Python': 1, 'is': 2, 'fun': 3}

أي أننا نستعمل مصفوفات tuples تحتوي على أزواج المفتاح و القيمة داخل قوسين ()، نجمعها كلها داخل قائمة [ ] و من ثمة نطبق عليها الدالة dict :

>>> a = ('Python',1)
>>> type(a)
<class 'tuple'>
>>> b = ('Language',2)
>>> type(b)
<class 'tuple'>
>>> c = [a,b]
>>> c
[('Python', 1), ('Language', 2)]
>>> type(c)
<class 'list'>
>>> d = dict(c)
>>> d
{'Python': 1, 'Language': 2}
>>> type(d)
<class 'dict'>
  • يمكن استعمال الدالة dict بطريقة أخرى عندما تكون المفاتيح عبارة عن نصوص فقط:
>>> d = dict(Python=1, Language=2)
>>> d
{'Python': 1, 'Language': 2}
  • يمكن استعمال معاملات العضوية أيضا في القواميس (على المفاتيح فقط):
>>> d
{'Python': 1, 'Language': 2}
>>> 'Python' in d
True
>>> 'Python' in d
True
  • يمكن إنشاء قاموس باستعمال حلقة معينة تحسب القيم و المفاتيح بشكل أوتوماتيكي:
>>> d1 = { number : number + 2 for number in range(4)}
>>> d1
{0: 2, 1: 3, 2: 4, 3: 5}

المفتاح هو number و القيمة هي number + 2 ، و الأعداد التي سيحملها المفتاح توجد في الدالة range(4) ، أي أن المفاتيح ستكون الأعداد من 0 إلى 3 ، قيمة كل مفتاح تساوي قيمة المفتاح زائد العدد 2 .

  • يمكن حساب عدد الأزواج المتواجدة في قاموس ما باستعمال الدالة len :
>>> d1
{0: 2, 1: 3, 2: 4, 3: 5}
>>> len(d1)
4

المصفوفات Tuples

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

قواعد إنشاء مصفوفة

  • المصفوفة تجمع بين المتغيرات من خلال وضع فاصلة بينها :
tuple1 = 1,2,"Python",4
  • يمكن وضع المتغيرات داخل الأقواس و لكن هذا ليس ضروريا:
tuple1 = (1,2,"Python",4)
  • يمكن للمصفوفات أن تحتوي على مصفوفات أخرى Nested tuples :
>>> tuple1 = (1,2,3),(4,5,6)
>>> tuple1
((1, 2, 3), (4, 5, 6))
  • عند إنشاء مصفوفة بمتغير واحد، لا بد من إضافة الفاصلة على اليمين:
tuple1 = (1,)

ملاحظة: إذا لم نضِف الفاصلة، سيعتبر المترجم المتغير tuple1 كـ integer .

>>> tuple1 = (1)
>>> type(tuple1)
<class 'int'>
  • يمكن إنشاء مصفوفة باستعمال الدالة tuple :
tuple1 = tuple("Python")

عند استعمال الدالة tuple و إدخال قيمة نصية، فإنها تُنشئ مصفوفة تحتوي على حروف النص. عند إظهار المتغير tuple1 في الشفرة أعلاه، نحصل على النتيجة التالية:

('P', 'y', 't', 'h', 'o', 'n')

يمكن استعمال هذه الدالة على القوائم أيضا:

>>> l = [1,2,3,4,5]
>>> t = tuple(l)
>>> t
(1, 2, 3, 4, 5)
  • يمكن فهرسة المصفوفات أيضا كالقوائم – Indexing :
>>> t = tuple("Shafrah")
>>> t[5]
'a'
>>> t[3]
'f'
>>> t[-3]
'r'
  • يمكن إنشاء نسخة عن المصفوفة – Creating a copy :
>>> t = tuple("Shafrah")
>>> copy = t[0:]
>>> copy
('S', 'h', 'a', 'f', 'r', 'a', 'h')
  • أو نسخ جزء معين فقط – Slicing :
>>> t = tuple("Shafrah")
>>> s = t[1:5]
>>> s
('h', 'a', 'f', 'r')
  • لا يمكن تغيير عنصر من عناصر المصفوفة لأنها غير قابلة للتغيير – immutable :
>>> t
('S', 'h', 'a', 'f', 'r', 'a', 'h')
>>> t[2] = "i"
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    t[2] = "i"
TypeError: 'tuple' object does not support item assignment
  • يمكن للمصفوفة أن تحتوي على عناصر قابلة للتغيير – mutable :
>>> t = [1,2,4],[4,5,6]
>>> t
([1, 2, 4], [4, 5, 6])
>>> t[0][2]
4
>>> t[0][2] = 3
>>> t
([1, 2, 3], [4, 5, 6])
  • يمكننا تخزين كل عنصر من المصفوفة في متغير محدد كالتالي:
  1. عندما نُخزن بيانات معينة في مصفوفة، نُسمي هذه العملية بـ tuple packing.
  2. عندما نُخزن عناصر المصفوفة في متغيرات منفصلة، نسمي هذا tuple unpacking.

عند تخزين العناصر في متغيرات منفصلة، يجب أن يكون عدد المتغيرات مساويا لعدد العناصر في مصفوفة ما:

>>> t = "One","Two","Three","Four","Five"
>>> a,b,c,d,e = t
>>> a
'One'
>>> b
'Two'
>>> c
'Three'
>>> d
'Four'
>>> e
'Five'

المجموعات Sets

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

تدعم المجموعات مفاهيم رياضية كالإتحاد، التقاطع، الفرق…

قواعد إنشاء المجموعات

  • يتم إنشاء مجموعة باستعمال اللامتين {} و إدخال البيانات داخلها مباشرة:
>>> s = {'A','B','C','D','E'}
>>> s
{'E', 'D', 'C', 'B', 'A'}
>>> type(s)
<class 'set'>
  • عند إدخال قيم متكررة، تُحذف القيم الزائدة و تبقى قيمة واحدة:
>>> s = {'A','B','A','C','D','E','E','E','E'}
>>> s
{'E', 'D', 'C', 'B', 'A'}
  • يمكن إنشاء مجموعة باستعمال الدالة set :
>>> set("SHAFRAH")
{'F', 'S', 'R', 'H', 'A'}
>>> set("Python")
{'t', 'y', 'P', 'h', 'o', 'n'}
>>> l = [1,2,3,4,5]
>>> set(l)
{1, 2, 3, 4, 5}
  • يمكن حساب عدد العناصر في مجموعة ما باستعمال الدالة len :
>>> s
{'E', 'D', 'C', 'B', 'A'}
>>> len(s)
5
  • يمكن التأكد من تواجد عنصر ما في مجموعة معينة باستعمال معاملات العضوية:
>>> 'A' in s
True
>>> 'F' not in s
True
  • لإظهار قيم توجد في مجموعة ما فقط و لا توجد في مجموعة أخرى:
>>> a = {1,2,3,4,5,6}
>>> b = {2,5,7,9,6}
>>> a - b
{1, 3, 4}

القيم 1 و 3 و 4 توجد في المجموعة a فقط و لا توجد في المجموعة b

  • لإظهار قيم توجد في المجموعة a أو المجموعة b أو كليهما:
>>> a
{1, 2, 3, 4, 5, 6}
>>> b
{2, 5, 6, 7, 9}
>>> a | b
{1, 2, 3, 4, 5, 6, 7, 9}
  • لإظهار قيم توجد في a و b :
>>> a
{1, 2, 3, 4, 5, 6}
>>> b
{2, 5, 6, 7, 9}
>>> a &amp; b
{2, 5, 6}
  • لإظهار قيم توجد إما في a أو في b و لا توجد فيهما معا:
>>> a
{1, 2, 3, 4, 5, 6}
>>> b
{2, 5, 6, 7, 9}
>>> a ^ b
{1, 3, 4, 7, 9}
  • يمكن استعمال الحلقات أيضا داخل set لكي تُخزن البيانات بشكل أوتوماتيكي:
>>> s = { number for number in range(20) if number % 2 == 0}
>>> s
{0, 2, 4, 6, 8, 10, 12, 14, 16, 18}
السابق
خطوتك الأولى في تعلم البرمجة بلغة Java
التالي
طريقة تشغيل path في Java

شاركنا برأيك