ترجمة لسلسلةْ تعَلَّم بايثون3 مِن مدارسw3 كاملة python

بسم الله الرحمن الرحيم.
تجدون هنا ترجمة لجميع دروس سلسلة تعلم بايثون،
ترجمة الأستاذ إبرهيم حمادَة، بارك الله له ونفع به.
ولِمَن أراد الانتقال إلى الموقع الأصلي يمكنه ذلك من خلال الرابط التالي:
Python Tutorial
وكما تعَوَدْنا فالانتقال بين الدروس بالرقم 1، 
والانتقال بين ملحقات الدروس بالرقم 2،
والانتقال بين النماذج بالرقم 3.
كما يمكنكم تنزيل السلسلة كاملة في ملف  واحد بصيغة html,
أو ملفات متعددة بصيغة txt.
سلسلةْ تعَلَّم بايثون3 مِن مدارسw3 كاملة.html
سلسلةْ تعَلَّم بايثون3 مِن مدارسw3 كاملة.zip

أما الآن فمع الدرس الأول:
مُقدِمةٌ إلى بايثون
بايثون هي لغة برمجة شعبية. تم إنشاؤها من قِبَل Guido van Rossum ، وأطلقها في عام 1991.
هي تُستعمل لِ:
• تطوير الويب (server-side), 
• تطوير البرمجيات ، 
• الرياضيات ، 
• نظام البرمجة.
ماذا يمكن أن يفعل  بايثون ؟ 
• بيثون يمكن استخدامه على الخادم(Server) لإنشاء تطبيقات الويب.
• بيثون يمكن استخدامه جنبا إلى جنب مع البرمجيات لِإتمام العمل.
• بيثون يمكنه الاتصال بقواعد البيانات. كما أن هيمكنه أيضا قراءة و تعديل الملفات.
• بيثون يمكن أن يُستخدم في التعامل مع البيانات الكبيرة و المعقدة,  و يمكنه أيضا أن يقوم بعمليات رياضية (mathematics)
• بيثون يمكن استخدامه في النماذج الأولية السريعة, أو الإنتاج الجاهز في تطوير البرمجيات.
لماذا بايثون؟ 
• بايثون يعمل على مختلف المنصات (ويندوز, ماك, لينكس, Raspberry Pi, الخ).
• بيثون لديه تركيب لغوي بسيط مماثلة إلى اللغة الإنجليزية.
• بايثون لديه بناء الجملة الذي يسمح للمطورين لكتابة البرامج مع أَسطُر أقل من بعض لغات البرمجة الأخرى.
• يعمل Python على نظام مترجم (interpreter )، مما يعني أنه يمكن تنفيذ التعليمات البرمجية بمجرد كتابتها. 
وهذا يعني أن البرمجة الناشئة يمكن أن تكون سريعة جدا.
• بيثون يمكن التعامل معه في طريقة إجرائية ، بطريقةْ الكائنات (Object oriented way) أو بطريقةْ الوظيفة أو الدالة.
مِن الجيد أن نعرف
• أحدث إصدار رئيسي من بيثون هو بيثون 3 التي يجب أن تستخدمه في هذا البرنامج التعليمي. 
ومع ذلك ، بيثون 2 ، على الرغم من أن لم يتم تحديثه مع أي شيء آخر من التحديثات الأمنية لا تزال له شعبية كبيرة.
• في هذا البرنامج التعليمي سوف تتم كتابة بيثون في محرر النص. 
فمِن الممكن أن يُكتب بيثون في بيئات أُخرى، مثل محررات النصوص المتطورة و هي كثيرة مثل notepad++, و التي يمكن أن تكون مفيدة خاصةً  عند إدارة مجموعات أكبر من ملفات بيثون.
جملةْ بايثون مقارنة مع لغات البرمجة الأخرى
• بيثون تم تصميمه لقابلية القراءة، وبعض أوجه التشابه مع اللغة الإنجليزية مع تأثير من الرياضيات.
• يستخدم Python السطر الجديد لإكمال أمر ما ، على عكس لغات البرمجة الأخرى التي غالبًا ما تستخدم الفواصل المنقوطة أو الأقواس.
• بيثون يعتمد على المسافة البادئة، أو الإزاحة, وذلك باستخدام الفضاء الأبيض، لتحديد نطاق؛ مثل نطاق الحلقات والوظائف والفئات. 
تستخدم لغات البرمجة الأخرى غالباً أقواس مجعدة لهذا الغرض.

المثال:

print("Hello, World!")

النتيجة:
Hello, World!

تثبيت بايثون
سيتم تثبيت Python بالفعل على العديد من أجهزة الكمبيوتر الشخصية وأجهزة Mac.
للتحقق مما إذا كان لديك بيثون مثبت على جهاز كمبيوتر يعمل بنظام التشغيل Windows، 
ابحث في شريط البداية عن بيثون أو قم بتشغيل التالي على سطر الأوامر (cmd.exe):
C:\Users\Your Name>python --version
و أنت تعلم أن ال cmd أو سطر الأوامر عندما يفتح في البداية فإنه يفتح في مُجلَّد المستخدِم يعني:
C:\Users\Your Name>
و Your Name هو اسمك على الحاسوب طبعا.
للتحقق مما إذا كان لديك Python مثبتًا على نظام Linux أو Mac ، ثم افتح سطر الأوامر على نظام Linux أو افتح Terminal واكتب:
python --version
إذا وجدت أن Python  ليس مثبتًا  لديك على جهاز الكمبيوتر الخاص بك ، فيمكنك تنزيله مجانًا من موقع الويب التالي: 
https://www.python.org/
 
ديناميكية بيثون 
Python هي لغة برمجة مفسرة ، وهذا يعني أنكَ كَمطور تكتب ملفات Python (.py) في محرر نصي ثم تضع تلك الملفات في مترجم أو مفسر Python ليتم تنفيذها.
طريقة تشغيل ملف بيثون هي مثل هذا في سطر الأوامر:
C:\Users\Your Name>python helloworld.py
حيث "helloworld.py" هو اسم ملف python الخاص بك.
و يكون هنا بالطبع ملف helloworld.py في مُجلَّد المستخدِم. 
أو مِن الأصح أن نقول أنّ ملف بايثون ينبغي أن يكون في نفس مكان مُوجه الأوامر أو ال cmd.
دعونا نكتب ملف Python الأول ، المسمى helloworld.py ، والذي يمكن تنفيذه في أي محرر نصوص.

#helloworld.py
print("Hello, World!")

هو شيء سهل هاكذا.
احفظ ملفك. 
افتح سطر الأوامر ، وانتقل به إلى المسار أو المُجَلَّد  حيث قمت بحفظ ملفك ، 
وقم بكتابة هذا على سطر الأوامر:
python helloworld.py
فيبدو سطر الأوامر هكذا:
C:\Users\Your Name>python helloworld.py
و ذلك في حال وجود ملف helloworld.py في مُجلَّد المستخدِم.
نضغط إنتر
يجب أن تكون النتيجة كما يلي:
Hello, World!
تهانينا ، لقد قمتَ بكتابة وتنفيذ أول برنامج بايثون.
 
 سطر أوامر بايثون(Python Command Line)
لاختبار أَسطُر قليلة من التعليمات البرمجية في بيثون ، 
يكون أحيانًا الأسرع والأسهل عدم كتابة الكود في ملف. 
أصبح هذا ممكنًا لأنه يمكن تشغيل Python كسطر أوامر بحد ذاته.
اكتب ما يلي في سطر أوامر Windows أو Mac أو Linux:
C:\Users\Your Name>python
أو ، إذا لم يعمل أمر "python" ، يمكنك تجربة "py":
C:\Users\Your Name>py
بعد ذلك, و مِن خلال سطر أوامر بايثون الذي سيظهر, يمكنكَ كتابة أي أوامر أو تعبيرات في بايثون ، 
بما في ذلك مثالنا على hello world الذي قمنا به من وقت سابق في البرنامج التعليمي:
C:\Users\Your Name>python
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
هذا هو سطر أوامر بايثون
و يمكننا الآن كتابة أي أوامر أو تعبيرات لبايثون عليه, دعنا نجرب المثال السابق hello world.
>>> print("Hello, World!")
ملحوظة: نضغط إنتر لتنفيذ الأمر.
Hello, World!
عندما تنتهي من سطر أوامر python ، يمكنك ببساطة كتابة ما يلي لإنهاء واجهة سطر أوامر Python:
exit()
و بعدها سنعود إلى سطر أوامر النظام
و لإغلاق سطر أوامر النظام أو ال cmd نكتب عليه:
exit
و نضغط إنتر بالطبع.

تَلْميحات خارجية:
هذا البرنامج التعليمي يستخدم python3.6
لكن نحن نرى من الأفضل إستخدام python3.7, و هو الإصدار الذي يستخدمه NVDA حاليا.
و أنت لن تلاحظ أي فرق بينهما
و من أراد تنزيل python3.7, فهذا رابط مباشر له:
اضغط هنا للتنزيل

نموذج بسيط
محتوى الملف المرفق:
print("Hello, World!") 
اضغط هنا لتنزيل الملف

استخدام Notepad أو برنامج المفكرة في كتابةْ ملفات بايثون و تنفيذها.
-إعداد في NVDA ينبغي الإنتباه له:
إذا أردت الإستمرار في متابعةْ هذا البرنامج التعليمي, لتعلُّم لغةْ البرمجة بايثون
فهناك إعداد في NVDA, ينبغي الإنتباه له و ضبطه, و هو
Report symbol level, أو مستوى نُطق الرموز, و هو يجب أن يكون
All, يعني Symbol level all
لِأنك في مجال البرمجة, ينبغي أن تكون قادرا على سماع كل الرموز, و لا يفوتك أي واحد منها.

مِن الممكن طبعا استخدام أي محرر نصوص أنت متعوِّد عليه في كتابةْ ملفات بايثون
لكن بالنسبة للمبتدئين في تعَلُّم بايثون, فنحن ننصح باستخدام برنامج المفكرة أو Notepad.
و مما يساعد على استخدام Notepad لهذا الغرض
-إظهار إمتدادات الملفات على حاسوبك.
و لعمل ذلك في windows 10, إتبع التالي:
نضغط alt
ثُمَّ نتحرك بالسهم اليمين أو اليسار إلى
File tab
نضغط عليه بالمسافة, فتفتح قائمة
 نتحرك عليها بالسهم الأسفل إلى
Options
نضغط عليه إنتر
ستفتح محاورةْ Folder Options 
نضغط control+ tab, للوقوف على view property page
الآن نتحرك بالتاب إلى
Advanced settings: Files and Folders treeview
إذا كانت مغلقة, نفتحها بالسهم اليمين أو اليسار
ثُمَّ نتحرك بالسهم الأسفل لنقف على العنصر
Hide extensions for known file types-ON
فإذا كان هذا العنصر محددا, نضغط عليه بالمسافة لإزالةْ التحديد 
و تُلاحِظ أن آخر كلمة فيه قد صارت OFF بعدما كانت ON
و الآن نتحرك بالتاب إلى زر موافق, و نضغط عليه.
و نكون هكذا قد أنجزنا المهمة.

إنشاء ملف بايثون
يمكن بالطبع وضع ملفات بايثون في مُجلَّد المستخدم, و تنفيذهاهناك
لكن من الأفضل عمل مُجلَّد خاص ننشِىء فيه ملفات بايثون, و نتدرب فيه عليها
لذلك سنُنْشِئ مُجلَّد في مُجلَّد المستخدم, وو نسميه مثلا learningPython
ندْخُل إلى المُجَلَّد الذي عملناه, يعني learningPython
الآن هنا, نريد أن نعمل ملف نصي , new text document
نضغط
alt, ثُمَّ h, ثُمَّ w
في القائمة التي ستظهر, نتحرك بالسهم الأعلى إلى العنصر
Text Document
نضغط عليه إنتر
سيظهر الملف بإسم New Text Document.txt, و تكون New Text Document محددة
نضغط control+ a, لتحديد الكل يعني New Text Document.txt
و نكتب مثلا test.py, يعني أننا أسمينا الملف test بإمتداد .py
ستظهر رسالة تحذرنا من تغيير إمتداد الملف, و تقول هل أنت متأكد أنك تريد تغيير إمتداد الملف
و نكون بشكل طبيعي واقفين على زر Yes, أو نعم, فنضغط إنتر للموافقة فورا.

لقد أتممْنا إنشاء الملف test.py, الآن نريد أن نفتحه, فنضغطْ عليه إنتر
إذا لم يفتح ببرنامج المفكرة أو Notepad, ربما تفتح محاورةْ تقول لك "كيف تريد أن تفتح الملف"
حسناً, إذا ظهرت تلك المحاورة, تحرك عليها بالتاب لتقف على قائمةْ البرامج
 إختر من القائمة Notepad
 ثُمَّ تحرك بالتاب إلى 
 Always use this app to open .py files 
 إضغط عليه بالمسافة لتحديده, ثُمَّ تحرك بالتاب إلى زر موافق و اضغطْ عليه.
المهم أن نكون قادرين في النهاية على فتح  الملف بواسطةْ برنامج المفكرة أو Notepad.
حسناً, نحن الآن فتحنا الملف test.py, و هو الآن طبعا فارغ.
أُكتب فيه:
print("I am learning python")
إضغط control+s لحفظ الملف.
الآن نحن نريد تنفيذ الملف, كيف نعمل ذلك؟ بواسطةْ سطر الأوامر طبعا.

استخدام سطر الأوامر لتنفيذ الملف
نفتح ال cmd أو سطر الأوامر
و يمكن ذلك بالضغط على زر الوندوس على الحاسوب, ثُمَّ في مربع البحث نكتب 
cmd
أول نتيجة ستظهر هي cmd.exe, و هو المطلوب, فنضغط إنتر.
و كما ذكرنا سابقا, فإنَّ سطر الأوامر عندما يفتح , في البداية يكون أو يفتح في مُجلَّد المستخدم
فهو عندي مثلا كذلك
C:\Users\ibra>
نريد الآن أن ننقُل أو نجُر سطر الأوامر إلى داخل المُجَلَّد الذي عملناه, learningPython
فنستخدم أمر cd و هو يعني change directory
فنكتب على سطر الأوامر: cd learningPython
C:\Users\ibra>cd learningPython
نضغط إنتر
فيدخل سطر الأوامر إلى مُجلَّد learningPython
و يبدو كذلك
C:\Users\ibra\learningPython>
الآن سطر الأوامر موجود حيث يوجد ملف بايثون test.py
فلِكي ننفذ الملف, نكتب بكل بَساطة على سطر الأوامر:
python test.py
فيبدو كذلك
C:\Users\ibra\learningPython>python test.py
نضغط إنتر
فتكون النتيجة:
I am learning python
هذه النتيجة تُكتَب أو تُطبع على سطر الأوامر, و سنسمع NVDA يقرأها لنا على الفور عند ظهورها.

استخدام سطر الأوامر أو ال cmd في بايثون
سطر الأوامر الذي نستخدمه لتنفيذ ملفات بايثون, هو بالطبع سطر أوامر النظام
و يقال له أيضا الكوماند لاين, أو ال Console, أو ال command prompt.
قبل كل شيء, و مِن المهم جدا جدا جدا, التأكد من ضبط الإعداد التالي في NVDA
report dynamic content changes on
أو بالعربية
تفعيل الإعلان عن التغييرات التلقائية
فإذا كان Off
نضغط NVDA +5, لنجعله On
ثُمَّ نضغط control+ NVDA + C, لحفظ الإعدادات.
و ضبط هذا الإعداد هو شيء مهم جدا جدا للتعامل مع سطر الأوامر, الكتابة عليه, و سماع النتائج

-فتحْ سطر الأوامر
نستطيع فتح سطر الأوامر كما قلنا, من قائمةْ إبدأ, أو بالضغط على مفتاح ال Windows, ثُمَّ كتابةْ 
cmd 
أول نتيجة ستظهر هي command prompt, أو cmd.exe و هو المطلوب فنضغط إنتر

-خاصيَّةْ الإكمال التلقائي أو ال auto complete في سطر الأوامر.
عندما نفتح سطر الأوامر من قائمةْ إبدأ, فهو يفتح كما عرفنا في مُجَلَّد المستخدِم.
C:\Users\ibra>
و لنفترض أننا وضعنا ملفات بايثون التي نريد أن نتعامل معها, في مُجَلَّد أسميناه pythonLessons داخل مُجَلَّد المستندات documents.
يعني
C:\Users\ibra\Documents\pythonLessons
الآن نريد أن نَنْقل أو نجُر سطر الأوامر إلى مُجَلَّد pythonLessons
كما أسلفنا سابقا ايضا نستخدم الأمر cd
و لكن سنستفيد من خاصيَّةْ الإكمال التلقاءي في سطر الأوامر
فنكتب عليه: cd و أول حرف من كلمةْ documents يعني الحرف d
فيبدو سطر الأوامر كذلك:
C:\Users\ibra>cd d
نضغط تاب, فيقول desktop
نضغط تاب مرة أخرى, فيقول documents
نعم هذا الذي نريده
فإنَّ سطر الأوامر بعدما كتبنا عليه الحرف d, قد أكمل الكلمة عنَّا و صارت documents
C:\Users\ibra>cd Documents
الآن نريد أن نكمل المسار, فنكتب
\
يعني يصير سطر الأوامر هاكذا
C:\Users\ibra>cd Documents\
الآن نكتب أول حرف أو حرفين من كلمةْ pythonLessons, يعني p أو py
C:\Users\ibra>cd Documents\py
نضغط تاب فيقول, pythonLessons
لقد اختار لنا الكلمة التي نريدها, و اكتمل الآن المسار
C:\Users\ibra>cd Documents\pythonLessons
و عندما نسمع كلمةْ pythonLessons, 
نضغط إنتر فورا.
و هاكذا نكون قد أدخلنا سطر الأوامر في المُجَلَّد الذي نريد, و هو pythonLessons في مُجَلَّد المستندات.
الآن لنفترض أنه يوجد داخل مُجَلَّد pythonLessons, ملف اسمه helloWorld.py, و نريد تنفيذه
ماذا نفعل
نكتب على سطر الأوامر: python و أول حرف من كلمةْ helloWorld
C:\Users\ibra\Documents\pythonLessons>
C:\Users\ibra\Documents\pythonLessons>python h
نضغط تاب , فيقول helloWorld.py
خَلاص هو أكمل لنا اسم الملف
نضغط إنتر فيتنفذ الملف.
و هاكذا نكون قد تعرفنا على خاصيَّةْ الإكمال التلقاءي في سطر الأوامر, و التي إذا عرفنا كيف نستخدمها ستساعدنا كثيرا, و توفر علينا الكثير.

-طرق أخرى لفتح سطر الأوامر في مسار أو مُجَلَّد معين.
الآن نحن نعمل في مُجَلَّد pythonLessons في مُجَلَّد المستندات
لكننا لا نريد أن نفتح سطر الأوامر من قائمةْ إبدأ, ثُمَّ نَنْقُلُه إلى هنا
فهل ذلك ممكن
نعم
-بواسطةْ مسطرةْ العنوان, address pane
نتأكد من أننا موجودون داخل المُجَلَّد الذي نريد أن نفتح سطر الأوامر فيه, و ليكن مثلا pythonLessons
نضغط alt + d
فنقف على مسطرةْ العنوان, نكتب
cmd
 ثُمَّ  نضغط إنتر
فنلاحظ أن سطر الأوامر قد فُتِح في المُجَلَّد الذي نحن فيه
C:\Users\ibra\Documents\pythonLessons>

-الطريقة الأخرى باستخدام ملف .bat
قم بإنشاء ملف نصي جديد
New Text Document.txt
إفتحه و اكتب فيه هذا فقط:
start cmd.exe
إحفَظ الملف, و أغلقه, ثُمَّ أعِدْ تسميته إلى
openCmdHere.bat
الآن تستطيع أن تضعْ هذا الملف في المُجَلَّد الذي تريد, و عند الضغط عليه, سيفتح سطر الأوامر في نفس المكان.

-كيفيةْ قراءةْ النتائجْ على سطر الأوامر
على سطر الأوامر, نحن لا نستطيع استخدام السهم الأعلى و الأسفل لقراءةْ النتائج
و لكن باستخدام السهم الأعلى, يمكن أن نتصفح أو نقف على الأوامر السابقة التي نفذناها من قبل على سطر الأوامر.
أما بالنسبة لقراءةْ النتائج
فإن ذلك يكون باستخدام مؤشر NVDA
لكن نتأكد في البداية, من أنَّ نمط التصفح عندنا هو
نمط تصفح الكائنات, أو Object Review
و الذي يمكن أن نُحقِقَهُ بالضغط على 
NVDA + numpad1 على لوحةْ الأرقام
و الآن يمكن أن نستخدم
numpad7 لقراءةْ السطر السابق
numpad8 لقراءةْ السطر الحالي
numpad9 لقراءةْ السطر التالي
numpad4 لقراءةْ الكلمة السابقة
numpad5 لقراءةْ الكلمة الحالية
numpad6 لقراءةْ الكلمة التالية
numpad1 لقراءةْ الحرف السابق
numpad2 لقراءةْ الحرف الحالي
numpad3 لقراءةْ الحرف التالي
طبعا مع كَون لوحةْ الأرقام مغلقة.

-كيفيةْ النَسْخ من على سطر الأوامر
اختصارات  النسخ و اللصق المعتادين عليها, لا تعمل على سطر الأوامر
لذلك فعند نَسخ أي نتيجة أو نص من على سطر الأوامر, فإننا نعمل ذلك باستخدام مؤشر NVDA.
نتحرك بمؤشر NVDA, باستخدام الأوامر التي ذكرناها قبل قليل, للوصول إلى بدايةْ النص الذي نريد نسخه.
ثُمَّ نضغط
NVDA + F9
ثُمَّ نعود نتحرك بمؤشر NVDA, إلى نهايةْ النص الذي نريد نسخه, و نقف على آخر حرف منه.
و الآن نضغط
NVDA + F10 مرتين متتاليتين
فنسمع رسالة تقول لنا: 
Review selection copied to clipboard, أي قد تم نسخ النص إلى الحافظة.

لإغلاق سطر الأوامر, يمكن أن نكتب عليه exit, ثُمَّ نضغط إنتر
أو كما نغلق النوافذ الأخرى, بالضغط على alt + F4.

استخدام سطر أوامر بايثون, أو python console
-كما ذكرنا عند الأستعراض لسطر أوامر النظام, فإنهُ من المهم جدا جدا التأكد من ضبط هذا الإعداد في NVDA
report dynamic content changes on
و الذي يمكن تغييره بالإختصار, NVDA + 5
فيجب أن يكون هذا الإعداد مُفَعَّل, يعني On و ليس Off كي نستطيع التعامل مع سطر الأوامر من غير مشاكل.

لا ينبغي أن نخلط بين سطر أوامر بايثون و سطر أوامر النظام, فهما شيئان مختلفان طبعا.
-فتحْ سطر أوامر بايثون.
لِفتح سطر أوامر بايثون, لا بد أن نفتح أولا سطر أوامر النظام
نفتحه
C:\Users\ibra>
و نكتب عليه كلمةْ python
C:\Users\ibra>python
نضغط إنتر, فيظهر لنا هذا
Python 3.7.5 (tags/v3.7.5:5c02a39a0b, Oct 14 2019, 23:09:19) [MSC v.1916 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
هذا هو سطر أوامر بايثون.
على سطر أوامر بايثون, تستطيع أن تكتُب أي أمر أو تعبير من تعبيرات بايثون, ثُمَّ نضغط إنتر لتنفيذه.
>>> print("Hello world!")
النتيجة:
Hello world!
>>> print("مرحبا أيها العالم")
النتيجة:
مرحبا أيها العالم
>>> print("لا للتطبيع مع العدو الإسرائيلي")
النتيجة:
لا للتطبيع مع العدو الإسرائيلي
>>> 3+2
النتيجة:
5
>>> 3-2
النتيجة:
1
>>> 3*2
النتيجة:
6
>>> 3/2
النتيجة:
1.5
و في بايثون, فإنَّ علامةْ * تعني الضرب, و علامةْ / تعني القسمة.

-قِراءَةْ النتائجْ على سطر أوامر بايثون
كما هو الحال على سطر أوامر النظام,
لا نستطيع على سطر أوامر بايثون, استخدام السهم الأعلى و الأسفل لقراءةْ النتائج
و لكن نستطيع باستخدام السهم الأعلى و الأسفل, التنَقُّل على الأوامر الموجودة أو التي نفَّذناها سابقا.
فيمكن مثلا, التحرك بالسهم الأعلى لنقف على أول أمر كتبناه و هو: print("Hello world!")
نضغط إنتر و نحن واقفون عليه, فيتم تنفيذه من جديد

أما قِراءةْ النتائجْ على سطر أوامر بايثون, هو تماما مثل قرائتها على سطر أوامر النظام.
نتأكد مِن انَّ نمط التصفح لدينا هو, object review أو نمط تصفح الكائنات
و يمكن التحكم بهاذا الإعداد, بواسطةْ الإختصار NVDA+Numpad1 مِن على لوحةْ الأرقام و هي مغلقة.
ثُمَّ بعدها نستخدم أوامر التصفُح بمؤشر NVDA, 
لقراءةْ السطر التالي أو السابق او الكلمة التالية أو السابقة و ما إلى ذلك من أوامر تصفُّح النصوص بمؤشر NVDA.
و لقد ذكرنا ذلك في درس سطر أوامر النظام, فيمكن الرجوع إليه لمن أراد.

-نَسخ النتائج من على سطر أوامر بايثون
أيضا نقول هنا, أنَّ نَسخ النتيجة أو أي نص ما, هو تماما كما عمِلْنا  على سطر أوامر النظام.
إذاً, نتحرك بمؤشر NVDA لنقف على بدايةْ أو بلأحرى أول حرف من النص الذي نريد نسخه
نضغط NVDA +F9
ثُمَّ نستأنف التحرك بمؤشر NVDA, لنقف على نهايةْ بَل آخر حرف من النص الذي نريد نَسخَه
و نضغط NVDA + F10 مرتين متتاليتين
فنسمع رسالة تقول أنه قد تم نَسخ النص إلى الحافظة.

و لِإغلاق سطر أوامر بايثون
فإنهُ يمكن ذلك بكتابةْ الأمر exit() ثُمَّ الضغط إنتر
و أيضا يمكن ذلك بالضغط على الإختصار
control + Z ثُمَّ الضغط إنتر
عند إغلاق سطر أوامر بايثون في هذه الحالة, نعود لسطر أوامر النظام
و نستطيع  هنا استخدام الأمر exit, أو الإختصار Alt + F4 لِإغلاقه.
 كما أنه  يمكن أيضا إغلاق سطر أوامر بايثون بالإختصار Alt + F4, و هكذا لا نعود إلى سطر أوامر النظام, و نكون قد أغلاقناهما كليهما معاً.

استخدام بَوابةْ بايثون  في NVDA, أو NVDA python console
إنَّ بَوابةْ بايثون في NVDA, تؤدي و تقوم تقريبا بنفس العمل الذي يقوم به سطر أوامر بايثون.
و  هي برأينا تتفوق عليه, من حيث سهولةْ فتْحهاا و إغلاقها و نَسخ و قراءةْ النتائج عليها.

-فَتح بَوابةْ بايثون في NVDA
يمكن فتح بَوابةْ بايثون في NVDA, من خلال فتح قائمةْ NVDA
NVDA+N
ثُمَّ التحرك بالسهم الأسفل إلى  الأدوات, أو Tools submenu, ندْخلها
و في قائمةْ الأدوات هذه, نتحرك بالسهم الأسفل إلى Python console و نضغط عليها إنتر.
و هكذا تَفتح بَوابةْ بايثون

و لكن دعكَ مِن تلك الطريقة, فهناك طريقة أسهل و أفضل و هي الضغط على الإختصار
NVDA + Control + z
فتفتح البوابة
و يقول لك
NVDA Python Console
>>>
كما على سطر أوامر بايثون, الآن يمكنكَ كتابةْ أي أمر مِن أوامر بايثون , ثُمَّ الضغط إنتر لتنفيذه
>>> print("Hello NVDA")
فنسمعه يقول:
Hello NVDA
>>> print("لا للإحتلال الإسرائيلي, و لا للتطبيع معه")
فنسمعه يقول:
لا للإحتلال الإسرائيلي, و لا للتطبيع معه
>>> 5+2
فنسمعه يقول:
7
>>> 5-2
فنسمعه يقول:
3
>>> 5*2
فنسمعه يقول:
10
>>> 5/2
فنسمعه يقول:
2.5

الآن ماذا نفعل للوقوف على النتائج, و تصفُّحها و نَسخ ما نَشَاء منها
نضغط
F6
فنقف على نافذةْ النتائج, 
بَل و كل ما كتبناه على البوابة, الأوامر و النتائج معا.
هذه النافذة نستطيع تصفُّحها, بالطريقة العادية و بكل بَساطة
يعني باستخدام الإختصارات العادية التي نستعملها لتصفُّح أي نص في برنامج المفكرة أو word مثلا
و أيضا, إذا أردنا نَسخ أي نص أو مقطع منها, نقوم بتحديد النص بالطريقة العادية من غير أي مشاكل
ثُمَّ استخدام الإختصار المعتادون عليه أيضا
Control + C

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

و أخيرا إذا أردنا إغلاق بَوابةْ بايثون في NVDA, فإننا نعمل ذلك بكل بَساطة 
بالضغط على مفتاح الهروب, أو Escape.

بناء جملةْ بايثون [Python Syntax]

 في هذا الدرس:
تنفيذ تعبيرات بايثون
الإزاحة في بايثون أو Python Indentation
متغيرات بايثون
تعليقات بايثون
تمارين
 
تنفيذ بناء جملةْ بيثون
كما تعلمنا في الدرس السابق ، يمكن تنفيذ بناء جملة Python عن طريق الكتابة مباشرة في سطر الأوامر, سطر أوامر بايثون طبعا:
>>> print("Hello, World!")
Hello, World!
أو عن طريق إنشاء ملف python  ، باستخدام امتداد الملف .py ، وتشغيله بواسطةْ سطر أوامر النظام:
C:\Users\Your Name>python myfile.py
 و هنا افترضنا أنّ إسم الملف الذي عمِلْته هو myfile
 
الإزاحة في بايثون
الإزاحة تعني إلى المسافات الموجودة في بداية سطر التعليمات البرمجية.
و الإزاحة في بايثون في بدايةْ السطر, يمكن أن تكون بالمسافة أو التاب.
و من الأفضل استخدام التاب في الإزاحة في بايثون و هو الشائع.
إذا كانت الإزاحة  في الشفرة في لغات البرمجة الأخرى للقراءة فقط ، فإن الإزاحة في Python مهمة جدًا.
يستخدم Python الإزاحة في بدايةْ السطر للإشارة إلى مجموعة مُتَرابطة  مِن التعليمات البرمجية.
المثال
if 5 > 2:
	print("Five is greater than two!")

النتيجة:
Five is greater than two! 
جربها بنفسك  مِن ملف indentation.py

سيعطيك Python خطأ إذا تخَطَّيت أو تجاهلت الإزاحة:
مثال
خطأ في بناء الجملة(Syntax Error):
if 5 > 2:
print("Five is greater than two!")

النتيجة:
  File "indentation_test.py", line 2
    print("Five is greater than two!")
        ^
IndentationError: expected an indented block 
جربها بنفسك  في ملف indentation_test.py

عدد المسافات أو التابات في الإزاحة متروك لكَ كَمُبرمِج ، ولكن يجب أن تكون واحدة على الأقل.
مثال
if 5 > 2:
	print("Five is greater than two!") 
if 5 > 2:
			print("Five is greater than two!") 

النتيجة:
Five is greater than two!
Five is greater than two! 
جربها بنفسك  في ملف indentation2.py

يجب عليك استخدام نفس عدد المسافات أو التابات في نفس كتلة التعليمات البرمجية أو النطاق، 
وإلا فإن Python سيعطيك خطأ:
مثال
خطأ في بناء الجملة(Syntax Error):
if 5 > 2:
	print("Five is greater than two!")
			print("Five is greater than two!")

النتيجة:
  File "indentation2_error.py", line 3
    print("Five is greater than two!")
    ^
IndentationError: unexpected indent 
جربها بنفسك في ملف indentation2_error.py
 
  متغيرات بايثون
في بايثون ، يتم إنشاء المتغيرات عندما تقوم بإعطاء أو إسناد قيمة لها:
مثال
المتغيرات في بايثون:
x = 5
y = "Hello, World!"

print(x)
print(y)

النتيجة:
5
Hello, World! 
جربها بنفسك في ملف syntax_variables.py

لا يوجد في بايثون أي أمر للإعلان عن إنشاء متغير.
سوف تتعلم المزيد عن المتغيرات في فصل Python Variables .
 
 التعليقات في بايثون(Comments)
في Python هناك إمكانية التعليق لغرض التوضيح أو التوثيق داخل الكود.
يبدأ التعليق في بايثون بـ علامةْ # ، و سيعتبر Python باقي السطر كتعليق:
لذلك فإن مفسرْ بايثون أو منفذْ الكود, إذا وجدَ علامةْ # في بداية السطر, فإنه لن يفسر أو يهتم بذلك السطر.
مثال
التعليقات في بايثون:
#This is a comment.
print("Hello, World!")

النتيجة:
Hello, World! 
جربها بنفسك في ملف comment.py
 
 اختبر نفسك مع التمارين
تمرين:
أدخل الجزء المفقود من الكود أدناه لإخراج "Hello World".
... ("Hello World")


الإجابة:
الجزء المفقود هو كلمةْ print

نموذج على التعليقات:
#هذا تعليق.
print("مرحبا، كيف أنتم يا قوم")
نموذج على الإزاحة:
if 5 > 2:
	print("خمسة أكبر من اثنين")
أما إذا أخطأنا في الإزاحة فسيظهر لنا التالي:
if 5 > 2:
print("Five is greater than two!")
إن أردت قم بتنزيل النماذج من هنا

تعليقات بايثون [Python Comments]
يمكن استخدام التعليقات لشرح كود بايثون.
يمكن استخدام التعليقات لجعل الكود أكثر قابلية للقراءة.
يمكن استخدام التعليقات لمنع التنفيذ عند اختبار الكود.
 
إنشاء تعليق
تبدأ التعليقات بِرمز  #، وسيتجاهلها بايثون:
مثال
#This is a comment
print("Hello, World!")

ستكون النتيجة:
Hello, World!
جربها بنفسك في ملف comment1.py

يمكن وضع التعليقات في وسط السطر ، وسيتجاهل بايثون باقي السطر:
مثال
print("Hello, World!") #This is a comment

ستكون النتيجة:
Hello, World!
جربها بنفسك في ملف comment2.py

لا يُشترط أن تكون التعليقات نصًا لشرح الكود ، بل يمكن أيضًا استخدامها لمنع بايثون من تنفيذ الكود:
مثال
#print("Hello, World!")
print("Cheers, Mate!")

ستكون النتيجة:
Cheers, Mate!
جربها بنفسك في ملف demo_comment3.py
لاحِظْ أنّ السطر الأول في الكود السابق, لم يتنفذْ بسبب علامةْ التعليق. 
 
تعليقات متعددة الأسطر
اختبر نفسك مع التمارين
تمرين:
التعليقات في بايثون تُكتب بِرَمز خاص ، ما هو؟
 هذا تعليق

الجواب:
الرمز هو #
#هذا تعليق

نماذج حول التعليقات وأشكالِها
اضغط هنا لتنزيل الملفات

متغيرات بايثون
إنشاء المتغيرات
المتغيرات عبارة عن حاويات لتخزين قيَم البيانات.
على عكس لغات البرمجة الأخرى ، لا يوجد في Python أي أمر للإعلان عن إنشاء متغير.
يتم إنشاء المتغير في اللحظة التي تقوم فيها بإسناد قيمة له لأول مرة.
مثال
x = 5
y = "John"
print(x)
print(y)

ستكون النتيجة:
5
John 
جربها بنفسك في ملف variables1.py

لا يلزم التصريح  عند إنشاء المتغيرات  عن نوعها  ، بل يمكن تغيير نوعها بعد إنشائها.
مثال
x = 4 # x is of type int
x = "Sally" # x is now of type str
print(x)

ستكون النتيجة:
Sally 
جربها بنفسك في ملف variables2.py

يمكن إنشاء  متغيرات السلسلة النصِّيَّة, إما باستخدام علامات التنصيص المفردة أو المزدوجة:
مثال
x = "John"
# is the same as
x = 'John'
print(x)

ستكون النتيجة:
John
جربها بنفسك في ملف variables3.py

ستتعرَّف أكثر على أنواع البيانات ، مثل str(السلاسل النصِّيَّة) و int(الأعداد الصحيحة) في الفصل التالي.
 
أسماء المتغيرات
يمكن أن يكون للمتغير اسم قصير (مثل x و y) 
أو اسم وصفي أكثر (age, carname, total_volume). 
قواعد متغيرات بايثون:
• يجب أن يبدأ اسم المتغير بحرف أو بشرطة سفلية(_)
• لا يمكن أن يبدأ اسم المتغير برقم
• لا يمكن أن يحتوي اسم المتغير إلا على أحرف أبجدية أو أرقام وشُرَطا سفلية (_)
• أسماء المتغيرات حساسة لحالة الأحرف 
(age, Age and AGE هذه بالنسبة لبايثون ثلاثة متغيرات مختلفة)
مثال
#Legal variable names:
myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"

#Illegal variable names:
2myvar = "John"
my-var = "John"
my var = "John"

ستكون النتيجة:
  File "variable_names.py", line 10
    2myvar = "John"
         ^
SyntaxError: invalid syntax
جربها بنفسك في ملف variable_names.py

تذَكر أن أسماء المتغيرات حساسة لحالة الأحرف(حرف كبير أو حرف صغير)
  
إسناد  قيمة إلى متغيراتْ متعددة
يتيح لك Python, إسناد أو إعطاء قيَم لمتغيرات متعددة في سطر واحد:
مثال
x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)

ستكون النتيجة:
Orange
Banana
Cherry 
جربها بنفسك في ملف variables4.py

ويمكنك إسناد نفس القيمة لمتغيرات متعددة في سطر واحد:
مثال
x = y = z = "Orange"
print(x)
print(y)
print(z)

ستكون النتيجة:
Orange
Orange
Orange 
جربها بنفسك في ملف variables5.py
 
إظهار المتغيرات 
غالباً ما يتم استخدام print في بايثون لإخراج أو إظهار المتغيرات.
للجمعِ أو الدمج بين النص والمتغير, يستخدم Python العلامة +
مثال
x = "awesome"
print("Python is " + x)

ستكون النتيجة:
Python is awesome 
جربها بنفسك في ملف variables6.py

يمكنك أيضًا استخدام العلامة + لإضافةْ متغير إلى متغير آخر:
مثال
x = "Python is "
y = "awesome"
z =  x + y
print(z)

ستكون النتيجة:
Python is awesome 
جربها بنفسك في ملف variables7.py

بالنسبة للأرقام ، العلامة + تعمل كعلامةْ جمع عادية:
مثال
x = 5
y = 10
print(x + y)

ستكون النتيجة:
15 
جربها بنفسك في ملف variables8.py

إذا حاولت الجمع بين سلسلة ورقم ، فسوف يعطيك Python خطأ:
مثال
x = 5
y = "John"
print(x + y)

ستكون النتيجة:
TypeError: unsupported operand type(s) for +: 'int' and 'str' 
جربها بنفسك في ملف variables_test.py
 
 المتغيرات العامة أو الكُبرى
Global Variables
تُعرف المتغيرات التي يتم إنشاؤها خارج دالة (كما في جميع الأمثلة أعلاه) باسم المتغيرات العامة.
يمكن للجميع استخدام المتغيرات العامة ، سواء داخل الدالة(function) أو خارجها.
مثال
إنشاء متغير خارج دالة، واستخدامه داخل الدالة
x = "awesome"

def myfunc():
	print("Python is " + x)

myfunc()

ستكون النتيجة:
Python is awesome 
جربها بنفسك في ملف variables_global.py

إذا أنشأت متغيرًا بنفس الاسم داخل دالة ، فسيكون هذا المتغير محليًا ، ولا يمكن استخدامه إلا داخل الدالة. 
سيبقى المتغير العام الذي يحمل نفس الاسم كما كان ، global أو عاما وبنفس القيمة الأصلية التي كان عليها.
مثال
إنشاء متغير داخل دالة، بنفس اسم المتغير العام
x = "awesome"

def myfunc():
	x = "fantastic"
	print("Python is " + x)

myfunc()

print("Python is " + x)

ستكون النتيجة:
Python is fantastic
Python is awesome 
جربها بنفسك في ملف variables_global2.py
 
 The global Keyword
الكلمة global
عادةً ، عندما تُنشئ متغيرًا داخل دالة ، 
يكون هذا المتغير محليًا ، ولا يمكن استخدامه إلا داخل هذه الدالة.
لإنشاء متغير عام داخل دالة ، يمكنك استخدام الكلمة المُتعارف عليها global.
مثال
إذا كنت تستخدم داخل الدالة الكلمة global، فإن المتغير ينتمي إلى النطاق العام:
def myfunc():
	global x
	x = "fantastic"

myfunc()

print("Python is " + x)

ستكون النتيجة:
Python is fantastic 
جربها بنفسك في ملف variables_global3.py

أيضاً، استخدم الكلمة  global إذا كنتَ تريد تغيير متغير عمومي داخل دالة.
مثال
لتغيير قيمةْ متغير عام مِن داخل دالة ، أشِر إلى المتغير باستخدام الكلمة global:
x = "awesome"

def myfunc():
	global x
	x = "fantastic"

myfunc()

print("Python is " + x)

ستكون النتيجة:
Python is fantastic 
جربها بنفسك في ملف variables_global4.py
 
اختبر نفسك مع التمارين
التمرين:
قم بإنشاء متغير يُسمى carname وقم بإسناد القيمة Volvo له.
...= "..."

الإجابة: 
carname= "Volvo"

نماذج حول المتغيرات وأنواعِها
اضغط هنا لتصفحها

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

أنواع البيانات الأسااسية
في البرمجة ، يعد نوع البيانات مفهوما مهما.
يمكن للمتغيرات تخزين البيانات من أنواع مختلفة ، 
وأنواع مختلفة مِن البيانات يمكن أن تفعل أشياء مختلفة.
يحتوي Python على أنواع البيانات التالية المضَمَّنة افتراضيًا ، و هي يمكن أن تكون مِن هذه الفئات:
السلسلة النصِّيَّة:
str
الأرقام:
intو floatو complex
أنواع السلاسل, و هي غير السلاسل النصِّيَّة:
listو tupleو range
النوع الذي يربط قيمة بقيمة أخرى:
dict
أنواع المجموعات:
set، frozenset
النوع المنطقي:
bool
الأنواع الثنائية(Binary Types):
bytesو bytearrayو memoryview
 
الحصول على نوع البيانات
يمكنك الحصول على نوع البيانات لأي كائن باستخدام الدالة type()
مثال
طباعة نوع البيانات للمتغير x:
x = 5
print(type(x))

ستكون النتيجة:
 
جربها بنفسك  في بوابةْ بايثون في NVDA.
و للتذكير
فإنَّ إدخال كود يتألف مِن أكثر مِن سطر في البوابة, يتم سطرا سطرا.
يعني نكتب أول سطر, و نضغط إنتر , ثُمَّ السطر الثاني و نضغط إنتر, 
و هاكذا إلى نهايةْ الكود.
 
تحديد نوع البيانات
في Python ، يتم تحديد نوع البيانات عند إسناد قيمة إلى متغير:
مثال عن نوع str
x = "Hello World"

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
Hello World
 
Try it » في ملف type_str.py

مثال عن نوع int
x = 20

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
20
 
Try it » مِن ملف type_int.py

مثال عن نوع float
x = 20.5

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
20.5
 
Try it » مِن ملف type_float.py

مثال عن نوع complex
x = 1j

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
1j
 
جربها بنفسك » في ملف type_complex.py

مثال عن نوع list
x = ["apple", "banana", "cherry"]

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
['apple', 'banana', 'cherry']

جربها بنفسك » مِن خلال ملف type_list.py

مثال عن نوع tuple
x = ("apple", "banana", "cherry")

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
('apple', 'banana', 'cherry')

جربها بنفسك » في ملف type_tuple.py

مثال عن نوع range
x = range(6)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
range(0, 6)

جربها بنفسك » بواسطةْ ملف type_range.py

مثال عن نوع dict
x = {"name" : "John", "age" : 36}

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
{'name': 'John', 'age': 36}

جربها بنفسك » بواسطةْ ملف type_dict.py

مثال عن نوع set
x = {"apple", "banana", "cherry"}

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
{'banana', 'cherry', 'apple'}

جربها بنفسك » بواسطةْ ملف type_set.py

مثال عن نوع frozenset
x = frozenset({"apple", "banana", "cherry"})

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
frozenset({'banana', 'cherry', 'apple'})

جربها بنفسك » بواسطةْ ملف type_frozenset.py

مثال على نوع bool
x = True

#display x:
print(x)

#display the data type of x:
print(type(x)) 

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

جربها بنفسك » بواسطةْ ملف type_bool.py

مثال عن نوع bytes
x = b"Hello"

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
b'Hello'

جربها بنفسك » بواسطةْ ملف type_bytes.py

مثال عن نوع bytearray
x = bytearray(5)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
bytearray(b'\x00\x00\x00\x00\x00')

جربها بنفسك » بواسطةْ ملف type_bytearray.py

مثال عن نوع memoryview
x = memoryview(bytes(5))

#display x:
print(x)

#display the data type of x:
print(type(x)) 

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


جربها بنفسك » مِن ملف type_memoryview.py
 
 
تحديد  نوع البيانات بشكل متعمد
إذا كنتَ تريد تحديد نوع البيانات مِن البداية ، يمكنك استخدام الوظائف أو الدوال المُنشئة(constructor) التالية:

مثال على الدالة str()
x = str("Hello World")

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
Hello World
 
جربها بنفسك » في ملف type_str2.py

مثال على الدالة int()
x = int(20)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
20
 
 جربها بنفسك» مِن ملف type_int2.py
 
 مثال على الدالة float()
x = float(20.5)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
20.5
 
Try it » بواسِطةْ ملف type_float2.py

مثال على الدالة complex()
x = complex(1j)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
1j
 
جربها بنفسك » مِن ملف type_complex2.py

مثال على الدالة list()
x = list(("apple", "banana", "cherry"))

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
['apple', 'banana', 'cherry']
 
جربها بنفسك » مِن ملف type_list2.py

مثال على الدالة tuple()
x = tuple(("apple", "banana", "cherry"))

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
('apple', 'banana', 'cherry')
 
جربها بنفسك » مِن ملف type_tuple2.py

مثال على الدالة range()
x = range(6)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
range(0, 6)
 
جربها بنفسك » مِن ملف type_range2.py

مثال على الدالة dict()
x = dict(name="John", age=36)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
{'name': 'John', 'age': 36}
 
جربها بنفسك » مِن ملف type_dict2.py

مثال على الدالة set()
x = set(("apple", "banana", "cherry"))

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
{'banana', 'cherry', 'apple'}
 
جربها بنفسك » مِن ملف type_set2.py

مثال على الدالة frozenset()
x = frozenset(("apple", "banana", "cherry"))

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
frozenset({'cherry', 'apple', 'banana'})
 
جربها بنفسك » مِن ملف type_frozenset2.py

مثال على الدالة bool()
x = bool(5)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
True
 
جربها بنفسك » مِن ملف type_bool2.py

مثال على الدالة bytes()
x = bytes(5)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
b'\x00\x00\x00\x00\x00'
 
 جربها بنفسك» مِن ملف type_bytes2.py
 
 مثال على الدالة bytearray()
x = bytearray(5)

#display x:
print(x)

#display the data type of x:
print(type(x)) 

ستكون النتيجة:
bytearray(b'\x00\x00\x00\x00\x00')
 
جربها بنفسك » مِن ملف type_bytearray2.py

مثال على الدالة memoryview()
x = memoryview(bytes(5))

#display x:
print(x)

#display the data type of x:
print(type(x)) 

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

 
جربها بنفسك » مِن ملف type_memoryview2.py
 
 
اختبر نفسك مع التمارين
تمرين:
مثال الكود التالي يطبع نوع بيانات x ، ما نوع البيانات التي ستكون؟
x = 5
print(type(x))
 

الإجابة: "
int

نماذج حول أنواع البيانات
اضغط هنا لتصفحها

الأرقامْ في بايثون
هناك ثلاثة أنواع رقمية في بايثون:
• int
• float
• complex
يتم إنشاء متغيرات الأنواع الرقمية في بايثون عندما تقوم بإسناد قيمة لها:
مثال
x = 1    # int
y = 2.8  # float
z = 1j   # complex
للتحقق من نوع أي كائن في بيثون، استخدم الدالة type()
مثال
x = 1
y = 2.8
z = 1j

print(type(x))
print(type(y))
print(type(z))

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


 
جربها بنفسك في ملف numbers.py
 
int
Int ، أو عدد صحيح ، هو عدد صحيح ، موجب أو سالب ، بدون كسور عشرية ، يمكن أن يكون كبيرا  و غير محدود.
مثال
عدد صحيح:
x = 1
y = 35656222554887711
z = -3255522

print(type(x))
print(type(y))
print(type(z))

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


 
جربها بنفسك في ملف numbers_int.py
 
Float
نوع float, أو الرقم العائم ، أو "رقم الفاصلة العائمة" هو رقم ، موجب أو سالب ، يحتوي على واحد أو أكثر من الكسور العشرية.
مثال
float:
x = 1.10
y = 1.0
z = -35.59

print(type(x))
print(type(y))
print(type(z))

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


 
جربها بنفسك في ملف numbers_float.py

يمكن أيضًا أن تكون Float أرقامًا علمية بحرف "e" للإشارة إلى قوة 10 power 10.
مثال
float:
x = 35e3
y = 12E4
z = -87.7e100

print(type(x))
print(type(y))
print(type(z))

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


 
جربها بنفسك مِن ملف numbers_float2.py
 
الأعداد المُرَكبة(Complex)
تتم كتابة الأعداد المُركبة بالحرف "j" باعتباره الجزء التخيلي:
مثال
complex:
x = 3+5j
y = 5j
z = -5j

print(type(x))
print(type(y))
print(type(z))

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


 
جربها بنفسك مِن ملف numbers_complex.py
 ملحوظة: هذا النوع مِ الأرقام(complex), لا يُستخدم كثيرا, و ليس مهما, لذلك لا داعي لصرف وقت كبير في محاولةْ فهْمَه.
 
التحويل مِ نوع إلى نوع آخر
يمكنك تحويل من نوع واحد إلى آخر بواسطةْ الدوال int()، float()و complex():
مثال
التحويل من نوع إلى آخر:
x = 1    # int
y = 2.8  # float
z = 1j   # complex

#convert from int to float:
a = float(x)

#convert from float to int:
b = int(y)

#convert from int to complex:
c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

ستكون النتيجة:
1.0
2
(1+0j)


 
جربها بنفسك مِن ملف numbers_convert.py
ملاحظة: لا يمكنك تحويل الأعداد المركبة إلى نوع آخر من الأرقام.
 
رقم عشوائي
لا يحتوي Python على وظيفة أو دالة random() لإنشاء رقم عشوائي ، 
لكن Python به وحدة برمجية(module or library) مضمَّنة تسمى randomوالتي يمكن استخدامها لإنشاء أرقام عشوائية:
مثال
استيراد مكتبةْ  random ، وعرض رقم عشوائي بين 1 و 9:
import random

print(random.randrange(1, 10))

النتيجة:
4 
#و  ربما يكون عندك الرقم مُختلف
جربها بنفسك مِن ملف numbers_random.py

في مرجع Random Module  الخاص بنا ، ستتعلم المزيد عن Random Module أو random library.
  
اختبر نفسك مع التمارين
التمرين:
أدخل الصيغة الصحيحة لتحويل x إلى رقم فاصلة عائمة, أو float.
x = 5
x = ... (x)

الإجابة :
x = float(x)

نماذج حول الأرقام في بايثون
اضغط هنا لِتَصَفُحِها

إضفاء نوع مِن أنواع البيانات على متغيرفي بيثون [Python Casting]
 
تحديد نوع متغير
قد تكون هناك أوقات تريد فيها تحديد نوع معين لمتغير ما. يمكن القيام بذلك عن طريق Casting. 
Python هي لغة تعتمد بشكل أساسي على التعامل مع  الكائنات ، 
وبالتالي فهي تستخدم الفئات لتحديد أنواع البيانات ، بما في ذلك الأنواع الأولية.
لذلك يتم إجراء ال casting في بيثون باستخدام وظائف المَنشَأ(constructor functions):
• int () - لإنشاء عددًا صحيحًا من عدد صحيح حرفي ، أو عدد رقمي عائم (عن طريق التقريب إلى العدد الصحيح السابق) ، 
أو سلسلة حرفية (شرط أن تكون  السلسلة تمثل عددًا صحيحًا)
• float () - لإنشاء عددًا عشريًا من عدد صحيح  ، أو عدد عشري حرفي 
أو سلسلة حرفية (شرط أن تكون  السلسلة تمثل عددًا عشريًا أو عددًا صحيحًا)
• str () - تُنشئ سلسلة نصِّيَّة من مجموعة متنوعة من أنواع البيانات ، بما في ذلك السلاسل النصية والرقمية الصحيحة والرقمية العائمة
مثال
الاعداد الصحيحه(Integers):
x = int(1)
y = int(2.8)
z = int("3")
print(x)
print(y)
print(z)

ستكون النتيجة:
1
2
3 
جربها بنفسك مِن ملف casting_int.py

مثال
الأعداد العشرية(Floats):
x = float(1)     # x will be 1.0
y = float(2.8)   # y will be 2.8
z = float("3")   # z will be 3.0
w = float("4.2") # w will be 4.2
print(x)
print(y)
print(z)
print(w)

ستكون النتيجة:
1.0
2.8
3.0
4.2 
جربها بنفسك مِن ملف float.py

مثال
السلاسل النصِّيَّة(Strings):
x = str("s1") # x will be 's1'
y = str(2)    # y will be '2'
z = str(3.0)  # z will be '3.0'
print(x)
print(y)
print(z)

ستكون النتيجة:
s1
2
3.0 
جربها بنفسك مِن ملف string.py

نماذج حول إضفاء نوع من البيانات إلى متغير
اضغط هنا لتصفحها أو تنزيلها

السلاسل النصِّيَّة
تُحاط السلاسل النصِّيَّة  في لغة بيثون إما بعلامات اقتباس مفردة أو بعلامات اقتباس مزدوجة.
'hello' هي نفسها "hello" .
يمكنكَ عرض سلسلة نصِّيَّة مع الدالة print()
مثال
print("Hello")
print('Hello')

ستكون النتيجة:
Hello
Hello 
جربها بنفسك مِن ملف string_literal.py
 
إسناد سلسلة نصِّيَّة إلى متغير
يتم إسناد سلسلة نصِّيَّة إلى متغير, باسم المتغير متبوعًا بعلامة يساوي ثُمَّ السلسلة:
مثال
a = "Hello"
print(a)

ستكون النتيجة:
Hello 
جربها بنفسك مِن ملف string_var.py

سلاسل متعددة الأسطُر
يمكنك إسناد سلسلة نصِّيَّة متعددة الأسطر إلى متغير باستخدام ثلاث علامات اقتباس:
مثال
يمكنك استخدام ثلاث علامات اقتباس مزدوجة:
a = """Hello world,
I am learning python,
I will be a programmer in the future,
and I will share in developing NVDA."""
print(a)

ستكون النتيجة:
Hello world,
I am learning python,
I will be a programmer in the future,
and I will share in developing NVDA.
جربها بنفسك مِن ملف string_multi.py

أو ثلاثة اقتباسات مفردة:
مثال
a = '''Hello world,
I am learning python,
I will be a programmer in the future,
and I will share in developing NVDA.'''
print(a)

ستكون النتيجة:
Hello world,
I am learning python,
I will be a programmer in the future,
and I will share in developing NVDA.
جربها بنفسك مِن ملف string_multi2.py
ملاحظة: في النتيجة ، يتم إدراج فواصل الأسطر في نفس الموضع كما في الكود.
  
السلاسل النصِّيَّة في بايثون عبارة عن صفائف(Arrays)
مثل العديد من لغات البرمجة الشائعة الأخرى ، فإن السلاسل في Python هي صفائف بايت(bytes) تمثل أحرف unicode.
ومع ذلك ، لا يحتوي Python على نوع بيانات الأحرف ، فالحرف الواحد هو ببساطة سلسلة نصِّيَّة بطول 1.
يمكن استخدام الأقواس المربعة للوصول إلى عناصر السلسلة النصِّيَّة.
مثال
الحصول على الحرف في الموضع(index) 1, تذَكر أن الحرف الأول له الموضع 0:
a = "Hello, World!"
print(a[1])

ستكون النتيجة:
e 
جربها بنفسك مِن ملف string1.py

التقطيع(Slicing) أو استخلاص جزء مِن السلسلة النصِّيَّة
يمكنك إستخلاص نطاق من الأحرف في السلسلة النصِّيَّة باستخدام طريقةْ التقطيع(Slicing).
حدد مكان البداية ومكان النهاية ، مفصولين بنقطتين فوقيتين، لإستخلاص جزء من السلسلة النصِّيَّة.
مثال
الحصول على الأحرف من الموضع 2 إلى الموضع 5 (غير مُتضَمَّن):
b = "Hello, World!"
print(b[2:5])

ستكون النتيجة:
llo 
جربها بنفسك مِن ملف string2.py

الفهرسة السلبية(Negative Indexing)
استخدم الفهارس السالبة(Negative Indexes) لبدء الشريحة من نهاية السلسلة:
ملاحظة: ال index لِآخِر حرف في السلسلة النصِّيَّة هو -1
مثال
الحصول على الأحرف من الموضع 5 إلى الموضع 1 (غير مدرج أو مُتضَمَّن) ، بدءًا من نهاية السلسلة:
b = "Hello, World!"
print(b[-5:-2])

ستكون النتيجة:
orl 
جربها بنفسك مِن ملف string_negativeindex.py

طول السلسلة النصِّيَّة
للحصول على طول سلسلة ، استخدم الدالة len().
مثال
الدالة len() تعطيك طول السلسلة:
a = "Hello, World!"
print(len(a))

ستكون النتيجة:
13 
جربها بنفسك مِن ملف string_len.py
 
وظائف أو دوال  السلسلة
لدى Python مجموعة من الوظائف المتضمَنَة التي يمكنك استخدامها في السلاسل النصِّيَّة.
مثال
تُزيل وظيفة strip() أي مسافة بيضاء من البداية أو النهاية:
a = " Hello, World! "
print(a.strip()) # returns "Hello, World!"

ستكون النتيجة:
Hello, World!
جربها بنفسك مِن ملف string_strip.py

مثال
تقوم الوظيفة lower() بإرجاع السلسلة إلى حالة الأحرف الصغيرة:
a = "Hello, World!"
print(a.lower())

ستكون النتيجة:
hello, world!
جربها بنفسك مِن ملف string_lower.py

مثال
تقوم الوظيفة upper() بتحويل السلسلة إلى حالة الأحرف الكبيرة:
a = "Hello, World!"
print(a.upper())

ستكون النتيجة:
HELLO, WORLD!
جربها بنفسك مِن ملف string_upper.py

مثال
الوظيفة replace(),تستبدل هذه الوظيفة جزء مِن السلسلة النصِّيَّة بجزء آخَر:
a = "Hello, World!"
print(a.replace("H", "J"))

ستكون النتيجة:
Jello, World!
جربها بنفسك مِن ملف string_replace.py

مثال
split()تقسم هذه الوظيفة السلسلة النصِّيَّة إلى سلاسل فرعية إذا وجدت في السلسلة مثيلات للفاصل:
a = "Hello, World!"
print(a.split(",")) # returns ['Hello', ' World!']

ستكون النتيجة:
['Hello', ' World!']
جربها بنفسك مِن ملف string_split.py
 
التحقق من السلسلة
للتحقق مما إذا كانت عبارة معينة أو حرف موجود في سلسلة، يمكننا استخدام الكلمات الرئيسية in أو not in.
مثال
تحقق مما إذا كانت عبارة " ain " موجودة في النص التالي:
txt = "The rain in Spain stays mainly in the plain"
x = "ain" in txt
print(x)

ستكون النتيجة:
True 
جربها بنفسك مِن ملف string_in.py

مثال
تحقق مما إذا كانت عبارة "ain" غير موجودة في النص التالي:
txt = "The rain in Spain stays mainly in the plain"
x = "ain"not in txt
print(x) 

ستكون النتيجة:
False 
جربها بنفسك مِن ملف string_not_in.py
 
دمج السلاسل النصِّيَّة(String Concatenation)
لضم أو دمج سلسلتين ، يمكنك استخدام علامةْ الجمع +.
مثال
دمج المتغير aمع المتغير bإلى المتغير c:
a = "Hello"
b = "World"
c = a + b
print(c)

ستكون النتيجة:
HelloWorld
جربها بنفسك مِن ملف string_concat.py

مثال
لإضافة مسافة بينهما ، أضف " ":
a = "Hello"
b = "World"
c = a + " " + b
print(c)

ستكون النتيجة:
Hello World
جربها بنفسك مِن ملف string_concat2.py
 
تنسيق السلسلة(String Format)
كما تعلَّمْنا في فصل Python Variables ، لا يمكننا الجمع بين السلاسل والأرقام مثل هذا:
مثال
age = 36
txt = "My name is John, I am " + age
print(txt)

ستكون النتيجة:
Traceback (most recent call last):
  File "string_format_error.py", line 2, in 
    txt = "My name is John, I am " + age
TypeError: must be str, not int 
جربها بنفسك مِن ملف string_format_error.py

لكن يمكننا الجمع بين السلاسل والأرقام باستخدام الوظيفة format().
تأخذ الوظيفة format () الوسيطات التي تم تمريرها وتنسيقها وتضعها في السلسلة حيث تكون العناصر النائبة {} :
مثال
استخدام الوظيفة format () لإدراج الأرقام في السلاسل:
age = 36
txt = "My name is John, and I am {}"
print(txt.format(age))

ستكون النتيجة:
My name is John, and I am 36 
جربها بنفسك مِن ملف string_format1.py

الوظيفة format() تأخذ عدد غير محدود من الوسائط، ويتم وضعها في العناصر النائبة المعنية:
مثال
quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))

ستكون النتيجة:
I want 3 pieces of item 567 for 49.95 dollars.
جربها بنفسك مِن ملف string_format2.py

يمكنك استخدام أرقام الفهرس (index numbers ) مثلا {0}للتأكد من وضع الوسيطات في العناصر النائبة الصحيحة:
مثال
quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))

ستكون النتيجة:
I want to pay 49.95 dollars for 3 pieces of item 567
جربها بنفسك مِن ملف string_format3.py
 
حرف التمرير(Escape Character)
لإدراج أحرف غير قانونية في سلسلة ، استخدم حرف التمرير.
حرف التمرير هو شرطة مائلة للخلف \متبوعة بالحرف الذي تريد إدراجه.
مثال على الحرف غير القانوني هو اقتباس مزدوج داخل سلسلة محاطة بعلامات اقتباس مزدوجة:
مثال
سوف تحصل على خطأ إذا كنت تستخدم علامات الاقتباس المزدوجة داخل سلسلة محاطة بعلامات اقتباس مزدوجة:
txt = "We are the so-called "Vikings" from the north."

ستكون النتيجة:
                                       ^
SyntaxError: invalid syntax 
جربها بنفسك مِن ملف string_escape_error.py

لإصلاح هذه المشكلة ، استخدم حرف التمرير \":
مثال
يسمح لك حرف التمرير باستخدام علامات الاقتباس المزدوجة عندما لا يُسمح لك عادةً:
txt = "We are the so-called \"Vikings\" from the north."
print(txt) 

ستكون النتيجة:
We are the so-called "Vikings" from the north. 
جربها بنفسك مِن ملف string_escape.py

أحرف التمرير الأخرى المستخدمة في بايثون:
\'
Single Quote
مثال
txt = 'It\'s alright.'
print(txt) 

ستكون النتيجة:
It's alright. 
Try it » مِن ملف string_escape2.py

\\
Backslash
مثال
txt = "This will insert one \\ (backslash)."
print(txt) 

ستكون النتيجة:
This will insert one \ (backslash). 
Try it » مِن ملف string_backslash.py

\n
New Line
مثال
txt = "Hello\nWorld!"
print(txt) 

ستكون النتيجة:
Hello
World! 
Try it » مِن ملف string_newline.py

\r
Carriage Return
مثال
txt = "Hello\rWorld!"
print(txt) 

ستكون النتيجة:
Hello
World! 
Try it » مِن ملف string_r.py

\t
Tab
مثال
txt = "Hello\tWorld!"
print(txt) 

ستكون النتيجة:
Hello	World! 
Try it » مِن ملف string_t.py

\b
Backspace
مثال
#This example erases one character (backspace):
txt = "Hello \bWorld!"
print(txt) 

ستكون النتيجة:
HelloWorld!
Try it » مِن ملف string_b.py

\f
Form Feed
 
\ooo
Octal value
مثال
#A backslash followed by three integers will result in a octal value:
txt = "\110\145\154\154\157"
print(txt) 

ستكون النتيجة:
Hello 
Try it » مِن ملف string_octal.py

\xhh
Hex value
مثال
#A backslash followed by an 'x' and a hex number represents a hex value:
txt = "\x48\x65\x6c\x6c\x6f"
print(txt) 

ستكون النتيجة:
Hello
Try it » مِن ملف string_hex.py
 
وظائف السلسلة النصِّيَّة(String Methods)
يحتوي Python على مجموعة من الوظائف المضَمَّنة التي يمكنك استخدامها في السلاسل.
ملاحظة: تقوم جميع وظائف السلسلة بإرجاع قيَم جديدة. إنها لا تُغير السلسلة الأصلية.
Method
Description
capitalize()
تقوم بتحويل الحرف الأول مِن السلسلة إلى حرف كبير
casefold()
تقوم بتحويل السلسلة إلى حالة الأحرف الصغيرة
center()
تقوم بإرجاع سلسلة مركزية(موجودة في الوسط)
count()
تقوم بإرجاع عدد المرات التي تتكرر فيها قيمة معينة في سلسلة
encode()
تقوم بإرجاع نسخة مشفرة من السلسلة
endswith()
تقوم بإرجاع true إذا انتهت السلسلة بالقيمة المحددة
expandtabs()
تقوم بتحديد حجم علامة التبويب في السلسلة
find()
تقوم بالبحث في السلسلة عن قيمة محددة وإرجاع موضع المكان الذي تم العثور عليها فيه
format()
تقوم بتنسيق أو إدراج القيم المحددة في سلسلة
format_map()
تقوم بتنسيق أو إدراج القيم المحددة في سلسلة
index()
تقوم بالبحث في السلسلة عن قيمة معينة وإرجاع موضع المكان الذي تم العثور عليها فيه
isalnum()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة أبجدية رقمية(alphanumeric)
isalpha()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة في الأبجدية(in the alphabet)
isdecimal()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة عشرية(decimals)
isdigit()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة هي أرقام
isidentifier()
تقوم بإرجاع True إذا كانت السلسلة هي identifier, أو تصلح لِأن تكون إسم لمتغير
islower()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة أحرف صغيرة
isnumeric()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة رقمية(numeric)
isprintable()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة قابلة للكتابة أو الطباعة
isspace()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة هي مساحات بيضاء(whitespaces)
istitle()
تقوم بإرجاع True إذا كانت السلسلة تتَّبع قواعد العنوان
isupper()
تقوم بإرجاع True إذا كانت جميع الأحرف في السلسلة هي أحرف كبيرة
join()
Joins the elements of an iterable to the end of the string
ljust()
تقوم بإرجاع نسخة محايدة إلى اليسار من السلسلة
lower()
تقوم بتحويل السلسلة إلى حالةْ الأحرف الصغيرة
lstrip()
تقوم بإرجاع نسخة محذوف منها أشياء مِن  اليسار من السلسلة
maketrans()
تقوم بإرجاع جدول ترجمة لاستخدامه في الترجمة
partition()
تقومبإرجاع الصفوف (tuple) حيث يتم تقسيم السلسلة إلى ثلاثة أجزاء
replace()
تقوم بإرجاع سلسلة حيث يتم استبدال قيمة معينة بقيمة أُخرى معينة
rfind()
تقوم بالبحث في السلسلة عن قيمة محددة وإرجاع الموضع الأخير الذي تم العثور عليها فيه
rindex()
تقوم بالبحث في السلسلة عن قيمة محددة وإرجاع الموضع الأخير الذي تم العثور عليها فيه
rjust()
تقوم بإرجاع نسخة محايدة إلى اليمين من السلسلة
rpartition()
تبحث وظيفة rpartition () عن آخر تكرار لسلسلة محددة ، ويقسم السلسلة إلى مجموعة تحتوي على ثلاثة عناصر.
rsplit()
وظيفة rsplit () تقسم السلسلة إلى قائمة ، تبدأ من اليمين.
rstrip()
تقوم بإرجاع نسخة محذوف منها المسافات الفارغة في نهاية السلسلة.
split()
تقوم بتقسيم السلسلة عند فاصل معين ، وإرجاع قائمة
splitlines()
تقوم بتقسيم السلسلة عند نهايةْ  الأسطر وإرجاع قائمة
startswith()
تقوم بإرجاع true إذا بدأت السلسلة بالقيمة المحددة
strip()
تقوم بإرجاع نسخة محذوف منها المسافات الفارغة من بداية أو نهاية النص.
swapcase()
تبديل الحالات في السلسلة، تصبح الأحرف الصغيرة كبيرة والعكس بالعكس
title()
تقوم بتحويل الحرف الأول من كل كلمة إلى حرف كبير
translate()
تقوم بإرجاع سلسلة مترجمة(طبعا ليست الترجمة العادية التي نعرفها)
upper()
تقوم بتحويل السلسلة إلى حالة الأحرف الكبيرة
zfill()
تقوم بملء السلسلة  بعدد محدد من  الأصفار  في البداية
 
اختبر نفسك مع التمارين
التمرين:
استخدم الوظيفة len لِطباعة طول السلسلة.
x = "Hello World"
print(...)

الإجابة :
print(len(x))

نماذج حول السلاس النصية ودوالها المختلفة:
اضغط هنا لتنزيلها أو تصفحها

 القيم المنطقية في بيثون
 ملحوظة خارجية:
يُمكنك بكل بَساطة تجربةْ الأمثلة أو الكود الخاص بهذه الدروس في هذا البرنامج التعلييمي, في بوابةْ بايثون في NVDA(NVDA python console).
و نعني الأمثلة أو الكود, الذي يتألف مِن عدةْ أَسْطُر.
ففي إصدارات NVDA الحديثة, صارت بوابةْ بايثون تقبل إدخال أو لصق عدةْ أَسْطُر فيها.
يعني أنت تقوم في البداية بنسخ الكود المطلوب مَهما كان عدد الأسطر فيه
ثُم نفتح بوابةْ بايثون في NVDA, بالإختصار NVDA + Control + z
ثُمَّ نلصق فيها الكود بالإختصار الذي نعرفه Control+v
NVDA يقوم بإدخال الكود سطرا سطرا, و ستسمعه بعد إدخال كل سطر يقول
>>>
و عندما يتوقف أو ينتهي, يتبقى عليك أنت فقط أن تضغط إنتر لإدخال السطر الأخير.
ثُمَّ نضغط F6, للوقوف على نافذةْ النتيجة لنقرأها.
 
تمثل القيم المنطقية إحدى قيمتين: Trueأو False.
 
القيم المنطقية
في البرمجة ، غالبا ما تحتاج إلى معرفة ما إذا كان التعبير صحيحا أم خاطئا.  True أَم False.
يمكنك تقييم أي تعبير في بيثون، والحصول على واحدة من اثنين من الإجابات، True أو False.
عند مقارنةْ قيمتين ، يتم تقييم التعبير ويُرجع Python الإجابة المنطقية:
مثال
print(10 > 9)
print(10 == 9)
print(10 < 9)

ستكون النتيجة:
True
False
False 
جربها بنفسك  مِن ملف booleans1.py

عند استخدام شرط في عبارة If، يقوم Python بإرجاع True أو False:
مثال
طباعة رسالة استناداً إلى ما إذا كان الشرط True أو False:
a = 200
b = 33

if b > a:
	print("b is greater than a")
else:
	print("b is not greater than a")

ستكون النتيجة:
b is not greater than a 
جربها بنفسك مِن ملف booleans2.py
 
معرفة القيمة المنطقية للقيم والمتغيرات
الدالة bool() تسمح لك لتقييم أي قيمة، وتعطيك Trueأو False في المقابل،
مثال
تقييم سلسلة وعدد:
print(bool("Hello"))
print(bool(15))

ستكون النتيجة:
True
True 
جربها بنفسك  مِن ملف booleans3.py

مثال
تقييمْ متغيرَيْن(two variables):
x = "Hello"
y = 15

print(bool(x))
print(bool(y))

ستكون النتيجة:
True
True 
جربها بنفسك  مِن ملف booleans4.py
  
معظم القيم هي صواب True

يتم تقييم أي قيمة بشكل عام Trueإذا كانت تحتوي على نوع من المحتوى.
أي سلسلة(string)  هيTrue، باستثناء السلاسل الفارغة.
أي رقم, القيمة المنطقية له هو True، باستثناء 0.
أي قائمة(list) ، الصفوف (tuple) ، مجموعة(set) ، والقاموس(dictionary) قيمتها المنطقية هي صحيحة أو True، باستثناء تلك الفارغة.
مثال
الأمثلة التالية سوف ترجع True:
bool("abc")
bool(123)
bool(["apple", "cherry", "banana"])

ستكون النتيجة:
True
True
True 
جربها بنفسك  مِن ملف booleans5.py
 
بعض القيم هي False
في الواقع ، لا توجد العديد من القيم التي يتم تقييمها False، باستثناء القيم الفارغة ، 
مثل ()، []، {}، ""، الرقم 0، والقيمة None. 
وبالطبع يتم تقييم القيمة False إلى False.
مثال
الأمثلة التي ستَلي سَتُرجع False:
bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

ستكون النتيجة:
False
False
False
False
False
False
False 
جربها بنفسك  مِن ملف booleans6.py

يتم تقييم قيمة أو كائن آخر في هذه الحالة ، False,وهذا إذا كان لديك كائن مكون من فئة ذات وظيفة __len__ ترجع 0أو False:
مثال
class myclass():
	def __len__(self):
		return 0

myobj = myclass()
print(bool(myobj))

ستكون النتيجة:
False 
جربها بنفسك  مِن ملف booleans7.py
 
يمكن أن تُرجع الدوال أو الوظائف قيمة منطقية
يمكنك إنشاء وظائف تُرجع قيمة منطقية:
مثال
طباعة نتيجةْ,  أو القيمة التي تُرجعها الوظيفة:
def myFunction() :
	return True

print(myFunction())

ستكون النتيجة:
True 
جربها بنفسك  مِن ملف boolean_return.py

يمكنك تنفيذ التعليمات البرمجية بناءً على الإجابة المنطقية للدالة:
مثال
طباعة "YES!"  إذا أعادت الدالة True ، و إلَّا فقم بطباعة "NO!":
def myFunction() :
	return True

if myFunction():
	print("YES!")
else:
	print("NO!")

ستكون النتيجة:
YES! 
جربها بنفسك  مِن ملف boolean_return2.py

يحتوي Python أيضاً على العديد من الوظائف المضمَنة التي ترجع قيمة منطقية، مثل الدالة isinstance() التي يمكن استخدامها لتحديد ما إذا كان الكائن من نوع بيانات معين:
مثال
تحقق مما إذا كان الكائن عددًا صحيحًا أم لا:
x = 200
print(isinstance(x, int))

ستكون النتيجة:
True 
جربها بنفسك  مِن ملف booleans8.py
 
اختبر نفسك مع التمارين
التمرين:
العبارة أدناه سوف تطبع قيمة منطقية، فما هي؟
print(10 > 9)
 ...

الإجابة:
 True

نماذج حول التعبيرات المنطقية
اضغط هنا لتصفحها

مشغلات بايثون, Python Operators

مشغلات أو عوامل(Operators) بايثون
تُستخدم العوامل لإجراء عمليات على المتغيرات والقيم.
يُقَسِّم Python العوامل إذا المجموعات التالية:
• العمليات الحسابية
• عوامل الإسناد
• عوامل المقارنة
• العوامل المنطقية
• عوامل التأكد مِن الهوية
• مشغلي أو عوامل معرفةْ العضوية
• معاملات البت(Bitwise operators)
 
معاملات بايثون الحسابية
تُستخدم العوامل الحسابية مع القيم الرقمية لإجراء عمليات حسابية شائعة:

+
الجمع(Addition)
x + y
مثال
x = 5
y = 3

print(x + y)

ستكون النتيجة:
8 
Try it » مِن ملف oper_add.py

-
الطرح(Subtraction)
x - y
مثال
x = 5
y = 3

print(x - y)

ستكون النتيجة:
2 
Try it » مِن ملف oper_sub.py

*
الضرب(Multiplication)
x * y
مثال
x = 5
y = 3

print(x * y)

ستكون النتيجة:
15 
Try it » مِن ملف oper_mult.py

/
القِسمة(Division)
x / y
مثال
x = 12
y = 3

print(x / y)

ستكون النتيجة:
4 
Try it » مِن ملف oper_div.py

%
باقي القِسمة(Modulus)
x % y
مثال
x = 5
y = 2

print(x % y)

ستكون النتيجة:
1 
Try it » مِن ملف oper_mod.py

**
الأُسية(Exponentiation)
x ** y
مثال
x = 2
y = 5

print(x ** y) #same as 2*2*2*2*2

ستكون النتيجة:
32 
Try it » مِن ملف oper_exp.py

//
ناتج القِسمة بمعزل عن الباقي(Floor division)
x // y
مثال
x = 15
y = 2

print(x // y)

#the floor division // rounds the result down to the nearest whole number

ستكون النتيجة:
7 
Try it » مِن ملف oper_floordiv.py

عوامل الإسناد في بايثون(Assignment Operators)
تُستخدم عوامل الإسناد لتعيين أو إعطاء قيم للمتغيرات:

=
x = 5
مثال
x = 5

print(x)

ستكون النتيجة:
5 
Try it » مِن ملف oper_ass1.py

+=
x += 3
هي تُعادِل تماما :
x = x + 3
مثال
x = 5

x += 3

print(x)

ستكون النتيجة:
8
Try it » مِن ملف oper_ass2.py

-=
x -= 3
هي تُعادِل تماما:
x = x - 3
مثال
x = 5

x -= 3

print(x)

ستكون النتيجة:
2
Try it » مِن ملف oper_ass3.py

*=
x *= 3
هي تُعادِل تماما:
x = x * 3
مثال
x = 5

x *= 3

print(x)

ستكون النتيجة:
15 
Try it » مِن ملف oper_ass4.py

/=
x /= 3
هي تُعادِل تماما:
x = x / 3
مثال
x = 5

x /= 3

print(x)

ستكون النتيجة:
1.6666666666666667 
Try it » مِن ملف oper_ass5.py

%=
x %= 3
هي تُعادِل تماما:
x = x % 3
مثال
x = 5

x%=3

print(x)

ستكون النتيجة:
2
Try it » مِن ملف oper_ass6.py

//=
x //= 3
هي تُعادِل تماما:
x = x // 3
مثال
x = 5

x//=3

print(x)

ستكون النتيجة:
1 
Try it » مِن ملف oper_ass7.py

**=
x **= 3
هي تُعادِل تماما:
x = x ** 3
مثال
x = 5

x **= 3

print(x)

ستكون النتيجة:
125 
Try it » مِ ملف oper_ass8.py

&=
x &= 3
هي تُعادِل تماما:
x = x & 3
مثال
x = 5

x &= 3

print(x)

ستكون النتيجة:
1 
Try it » مِن ملف oper_ass9.py

|=
x |= 3
هي تُعادِل تماما:
x = x | 3
مثال
x = 5

x |= 3

print(x)

ستكون النتيجة:
7 
Try it » مِن ملف oper_ass10.py

^=
x ^= 3
هي تُعادِل تماما:
x = x ^ 3
مثال
x = 5

x ^= 3

print(x)

ستكون النتيجة:
6 
Try it » مِن ملف oper_ass11.py

>>=
x >>= 3
هي تُعادِل تماما:
x = x >> 3
مثال
x = 5

x >>= 3

print(x)

ستكون النتيجة:
0 
Try it » مِن ملف oper_ass12.py

<<=
x <<= 3
هي تُعادِل تماما:
x = x << 3
مثال
x = 5

x <<= 3

print(x)

ستكون النتيجة:
40 
Try it » مِن ملف oper_ass13.py
 ملاحظة: عوامل ال Bitwise هذه التي سبقت, مثل &, |, ^ و غيرها يمكن تجاوزها خصوصا لمن ليس لديه فكرة عن الأرقام الثنائية أو binary numbers.
 
عوامل المقارنة في بايثون
يتم استخدام عوامل المقارنة(Comparison operators ) لمقارنةْ قيمتين:

==
متساوية(Equal)
x == y
مثال
x = 5
y = 3

print(x == y)

# returns False because 5 is not equal to 3

ستكون النتيجة:
False 
Try it » مِن ملف oper_compare1.py

!=
لا تساوي(Not equal)
x != y
مثال
x = 5
y = 3

print(x != y)

# returns True because 5 is not equal to 3

ستكون النتيجة:
True 
Try it » مِن ملف oper_compare2.py

>
أكبر من(Greater than)
x > y
مثال
x = 5
y = 3

print(x > y)

# returns True because 5 is greater than 3

ستكون النتيجة:
True 
Try it » مِن ملف oper_compare4.py

<
أقل من(Less than)
x < y
مثال
x = 5
y = 3

print(x < y)

# returns False because 5 is not less than 3

ستكون النتيجة:
False 
Try it » مِن ملف oper_compare5.py

>=
أكبر من أو يساوي(Greater than or equal to)
x >= y
مثال
x = 5
y = 3

print(x >= y)

# returns True because five is greater, or equal, to 3

ستكون النتيجة:
True 
Try it » مِن ملف oper_compare6.py

<=
أقل من أو يساوي(Less than or equal to)
x <= y
مثال
x = 5
y = 3

print(x <= y)

# returns False because 5 is neither less than or equal to 3

ستكون النتيجة:
False 
Try it » مِن ملف oper_compare7.py
 
عوامل بايثون المنطقية
تُستخدم المعاملات المنطقية(Logical operators ) لِدمج العبارات الشرطية:

and 
Returns True if both statements are true
تُرجع True إذا كانت كلتا  العبارتين صحيحتين
x < 5 and  x < 10
مثال
x = 5

print(x > 3 and x < 10)

# returns True because 5 is greater than 3 AND 5 is less than 10

ستكون النتيجة:
True 
Try it » مِن ملف oper_logical1.py

or
Returns True if one of the statements is true
تُرجع True إذا كانت أحدى العبارتين صحيحة
x < 5 or x < 4
مثال
x = 5

print(x > 3 or x < 4)

# returns True because one of the conditions are true (5 is greater than 3, but 5 is not less than 4)

ستكون النتيجة:
True 
Try it » مِن ملف oper_logical2.py

not
Reverse the result, returns False if the result is true
تعكس النتيجة ، وتُرجع False إذا كانت النتيجة True
not(x < 5 and x < 10)
مثال
x = 5

print(not(x > 3 and x < 10))

# returns False because not is used to reverse the result

ستكون النتيجة:
False 
Try it » مِن ملف oper_logical3.py
 
معاملات الهوية في بايثون
تُستخدم عوامل الهوية(Identity operators ) لمقارنة الكائنات ، ليس إذا كانت متساوية ، ولكن إذا كانت في الواقع نفس الكائن ، مع نفس موقع الذاكرة:

is 
Returns True if both variables are the same object
تُرجع True إذا كان كلا المتغيرَين هما نفس الكائن
x is y
مثال
x = ["apple", "banana"]
y = ["apple", "banana"]
z = x

print(x is z)

# returns True because z is the same object as x

print(x is y)

# returns False because x is not the same object as y, even if they have the same content

print(x == y)

# to demonstrate the difference betweeen "is" and "==": this comparison returns True because x is equal to y

ستكون النتيجة:
True
False
True 
Try it » مِن ملف oper_identity1.py

is not
Returns True if both variables are not the same object
تُرجع True إذا كان كلا المتغيرَين ليسا نفس الكائن
x is not y
مثال
x = ["apple", "banana"]
y = ["apple", "banana"]
z = x

print(x is not z)

# returns False because z is the same object as x

print(x is not y)

# returns True because x is not the same object as y, even if they have the same content

print(x != y)

# to demonstrate the difference betweeen "is not" and "!=": this comparison returns False because x is equal to y

ستكون النتيجة:
False
True
False 
Try it » مِن ملف oper_identity2.py
 
معاملات العضوية في بايثون
تُستخدم معاملات  العضوية(Membership operators ) لاختبار ما إذا كانت  سلسلة(sequence ) موجودة في كائن:

in 
Returns True if a sequence with the specified value is present in the object
تُرجع True إذا كان تسلسل قيمة محددة موجودة في الكائن
x in y
مثال
x = ["apple", "banana"]

print("banana" in x)

# returns True because a sequence with the value "banana" is in the list

ستكون النتيجة:
True 
Try it » مِن ملف oper_membership1.py

not in
Returns True if a sequence with the specified value is not present in the object
تُرجع True إذا كانت ِقيمة  سلسلة  محددةغير موجودة في الكائن
x not in y
مثال
x = ["apple", "banana"]

print("pineapple" not in x)

# returns True because a sequence with the value "pineapple" is not in the list

ستكون النتيجة:
True 
Try it » مِن ملف oper_membership2.py
 
معاملات Python Bitwise(Bitwise operators )
ملاحظة: مَن ليس عنده فكرة عن ال binary numbers, يمكنه تجاوز هذا الموضوع, لإنَّه ربما سيكون مِن الصعب عليه فهمه. 
تُستخدم معاملات Bitwise لمقارنة الأرقام (الثنائية) binary numbers:

& 
AND
Sets each bit to 1 if both bits are 1
تعيين كل بت إلى 1 إذا كان كلا البتين هي 1
|
OR
Sets each bit to 1 if one of two bits is 1
جعل البت 1, إذا كان أي مِن البتين هو 1
 ^
XOR
Sets each bit to 1 if only one of two bits is 1
جعل كل بت  1 إذا كان واحد فقط من الاثنين هو 1
~ 
NOT
Inverts all the bits
تعكس جميع البتات
<<
Zero fill left shift
Shift left by pushing zeros in from the right and let the leftmost bits fall off
الإزاحة لليسار عن طريق دفع الأصفار  من جهةْ اليمين والسماح للبت أقصى اليسار أن تسقط
>>
Signed right shift
Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off
الإزاحة لليمين, عن طريق دفع نسخ من البت أقصى اليسار  من اليسار ، والسماح للبت أقصى اليمين أن تسقط
 
اختبر نفسك مع التمارين
التمرين:
اضرب 10 مع 5، واطْبع النتيجة.
print(10 ... 5)

الإجابة :
print(10 * 5)

نماذج حول العوامل المختلفة
اضغط هنا لتصفحها

القوائم في بايثون

مجموعات بيثون (المصفوفات أو Arrays)
هناك أربعة أنواع من بيانات التجميع في لغة برمجة Python:
• القائمة(List ) هي مجموعة مرَتَّبة وقابلة للتغيير. 
يُسمح فيها بتكرار  العنصر.
• الصفوف (Tuple) هي مجموعة مرَتَّبة وغير قابلة للتغيير. 
يُسمح فيها بتكرار العنصر.
• Set هي مجموعة غير مرَتَّبة وغير مفهرسة(لا يمكنك تخمين موضع العنصر فيها). 
لا يوجد فيها أعضاء مكررون.
• القاموس(Dictionary ) عبارة عن مجموعة غير مرَتَّبة وقابلة للتغيير ومفهرسة. 
لا يوجد فيها أعضاء مكررون.
عند اختيار نوع المجموعة، من المفيد فهم خصائص هذا النوع. 
قد يعني اختيار النوع المناسب لمجموعة بيانات معينة الاحتفاظ بالمعنى ، وقد يعني ذلك زيادة في الكفاءة أو الأمان.

القائمة
القائمة هي مجموعة مرَتَّبة وقابلة للتغيير. في بايثون القوائم مكتوبة بأقواس مربعة.
مثال
إنشاء قائمة:
thislist = ["apple", "banana", "cherry"]
print(thislist)

ستكون النتيجة:
['apple', 'banana', 'cherry'] 
جربها بنفسك مِن ملف list.py
 
كيف نصلْ إلى العناصر في القائمة
يمكنك الوصول إلى عناصر القائمة بالرجوع إلى رقم الفهرس(index) للعنصر:
مثال
طباعة العنصر الثاني من القائمة:
thislist = ["apple", "banana", "cherry"]
print(thislist[1])

ستكون النتيجة:
banana 
جربها بنفسك  مِن ملف list_access.py
إنتبهْ إلى أنّ رقم الفهرس للعنصر الثاني هو 1
فالفهرسة في القائمة تبدأ بِ 0, فرقم الفهرس للعنصر الأول في القائمة هو دائما 0

الفهرسة السلبية(Negative Indexing)
تعني الفهرسة السلبية البدء من النهاية ، -1وتشير إلى العنصر الأخير ، -2وتشير إلى العنصر ما قبل الأخير  وما إلى ذلك.
مثال
طباعة العنصر الأخير من القائمة:
thislist = ["apple", "banana", "cherry"]
print(thislist[-1])

ستكون النتيجة:
cherry 
جربها بنفسك  مِن ملف list_negative_index.py

نطاق الفهارِس
يمكنك تحديد نطاق من الفهارس عن طريق تحديد مكان بدء النطاق ومكان إنهاءه.
عند تحديد نطاق ، ستكون قيمة الإرجاع قائمة جديدة تحتوي على العناصر المحددة.
مثال
إرجاع العنصر الثالث والرابع والخامس:
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

ستكون النتيجة:
['cherry', 'orange', 'kiwi'] 
جربها بنفسك  مِن ملف list_range.py
ملاحظة: سيبدأ البحث في الفهرس 2 (مشمول) وينتهي في الفهرس 5 (غير مشمول).
تذَكْر أن العنصر الأول قيمةْ  الفهرس له هو 0.

من خلال ترك قيمة البدايةفي النطاق، سيبدأ النطاق عند العنصر الأول:
مثال
يُرجع هذا المثال العناصر من البداية إلى العنصر "orange":
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[:4])

ستكون النتيجة:
['apple', 'banana', 'cherry', 'orange'] 
جربها بنفسك  مِن ملف list_range2.py

من خلال ترك القيمة النهائية في النطاق، فإن النطاق سوف يذهب إلى نهاية القائمة:
مثال
يقوم هذا المثال بإرجاع العناصر من العنصر "cherry"  وإلى النهاية:
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:])

ستكون النتيجة:
['cherry', 'orange', 'kiwi', 'melon', 'mango'] 
جربها بنفسك  مِن ملف list_range3.py

نطاق الفهارس السلبية(Negative Indexes)
استخدِم الفهارس السلبية إذا كنت تريد بدء البحث من نهاية القائمة:
مثال
يقوم هذا المثال بإرجاع العناصر من index -4 (مضمنة) إلى index -1 (مستثناة)
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[-4:-1])

ستكون النتيجة:
['orange', 'kiwi', 'melon'] 
جربها بنفسك  مِن ملف list_range_negative.py
 
تغيير قيمة العنصر
لتغيير قيمةْ عنصر معين ، استخدِم رقم الفهرس الخاص به:
مثال
تغيير العنصر الثاني:
thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant"
print(thislist)

ستكون النتيجة:
['apple', 'blackcurrant', 'cherry'] 
جربها بنفسك  مِن ملف list_change.py
 
 
إنشاء حلقة على قائمة
يمكنك تكرار حلقة خلال عناصر القائمة باستخدام for
مثال
طباعة جميع العناصر الموجودةة في القائمة ، واحدا تلوَ الآخر:
thislist = ["apple", "banana", "cherry"]
for x in thislist:
	print(x)

ستكون النتيجة:
apple
banana
cherry 
جربها بنفسك  مِن ملف list_loop.py
سوف تتعلم المزيد عن الحلقات for في فصل Python For Loops .
 
التحقق من وجود العنصر في القائمة
لتحديد ما إذا كان عنصر معين موجودًا في القائمة ، استخدم الكلمة الرءيسية in:
مثال
تحقق مما إذا كان "apple" موجودا في القائمة:
thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
	print("Yes, 'apple' is in the fruits list")

ستكون النتيجة:
Yes, 'apple' is in the fruits list 
جربها بنفسك  مِن ملف list_in.py
 
طول القائمة
لِمعرفةْ عدد العناصر الموجودة في القائمة ، استخدم الوظيفة len():
مثال
طباعة عدد العناصر في القائمة:
thislist = ["apple", "banana", "cherry"]
print(len(thislist))

ستكون النتيجة:
3 
جربها بنفسك  مِن ملف list_len.py
 
إضافة عناصرإلى القائمة
لإضافة عنصر إلى نهاية القائمة ، استخدم الوظيفة append () :
مثال
استخدام الوظيفة append() لِإلحاق عنصرإلى القائمة:
thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)

ستكون النتيجة:
['apple', 'banana', 'cherry', 'orange'] 
جربها بنفسك  مِن ملف list_append.py

لإضافة عنصر إلى مكان أو index  معين في القائمة، استخدم الوظيفة insert () :
مثال
إدراج عنصر في المركز الثاني:
thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange")
print(thislist)

ستكون النتيجة:
['apple', 'orange', 'banana', 'cherry'] 
جربها بنفسك  مِن ملف list_insert.py
 
إزالةْ عنصر مِن القائمة
هناك عدة طرق لإزالة العناصر من القائمة:
مثال
تزيل الوظيفة remove() العنصر المعيَّن أو المحدد:
thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)

ستكون النتيجة:
['apple', 'cherry'] 
جربها بنفسك  مِن ملف list_remove.py

مثال
تقوم طريقة pop() بإزالة العنصر في الفهرس المحدد ، (أو العنصر الأخير إذا لم يتم تحديد الفهرس):
thislist = ["apple", "banana", "cherry"]
thislist.pop()
print(thislist)

ستكون النتيجة:
['apple', 'banana'] 
جربها بنفسك  مِن ملف list_pop.py

مثال
تزيل الكلمة الرئيسية del العنصر في الفهرس المحدد:
thislist = ["apple", "banana", "cherry"]
del thislist[0]
print(thislist)

ستكون النتيجة:
['banana', 'cherry'] 
جربها بنفسك  مِن ملف list_del.py

مثال
الكلمة del يمكن بها أيضا حذف القائمة بالكامل:
thislist = ["apple", "banana", "cherry"]
del thislist
print(thislist) #this will cause an error because you have succsesfully deleted "thislist".

ستكون النتيجة:
Traceback (most recent call last):
  File "list_del2.py", line 3, in 
    print(thislist) #this will cause an error because you have succsesfully deleted "thislist".
NameError: name 'thislist' is not defined 
جربها بنفسك  مِن ملف list_del2.py

مثال
الوظيفة clear()تُفرغ القائمة:
thislist = ["apple", "banana", "cherry"]
thislist.clear()
print(thislist)

ستكون النتيجة:
[] 
جربها بنفسك  مِن ملف list_clear.py
 
نَسخ القائمة
لا يمكنك نَسخ قائمة ببساطة عن طريق كتابة list2 = list1، لأنه: list2 سيكون فقط مرجعاً إلى list1، والتغييرات التي يتم إجراؤها في list1 سيتم إجراؤها تلقائيًاً في list2.
بمعنى آخر يمكن أن نقول أنّ list1، و list2 هما متغيران يُشيران إلى نفس الكائن.
توجد طرق لعمل نسخة ، إحدى الطرق هي استخدام وظيفةْ القائمة المضمنة copy().
مثال
قم بعمل نسخة من القائمة باستخدام الوظيفة copy()
thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)

ستكون النتيجة:
['apple', 'banana', 'cherry'] 
جربها بنفسك  مِن ملف list_copy.py

هناك طريقة أخرى لعمل نسخة وهي استخدام الوظيفة المضمَنة list().
مثال
قم بعمل نسخة من القائمة باستخدام الدالة list():
thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

ستكون النتيجة:
['apple', 'banana', 'cherry'] 
جربها بنفسك  مِن ملف list_copy2.py
 
كيفيةْ ضم  أو دمج قائمتين
هناك عدة طرق لضم أو دمج قائمتين أو أكثر في بايثون.
واحدة من أسهل الطرق هي باستخدام العلامة + .
مثال
ضم أو دمج قائمتين:
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list3 = list1 + list2
print(list3)

ستكون النتيجة:
['a', 'b', 'c', 1, 2, 3] 
جربها بنفسك  مِن ملف list_concat1.py

هناك طريقة أخرى لِضم أو دمج  قائمتين وهي إلحاق جميع العناصر من list2 في list1 ، واحدا تلو الآخر:
مثال
إلحاق list2 بالقائمة list1:
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:
	list1.append(x)

print(list1)

ستكون النتيجة:
['a', 'b', 'c', 1, 2, 3] 
جربها بنفسك  مِن ملف list_concat2.py

أو يمكنك استخدام الوظيفة extend () ، والغرض منها هو إضافة عناصر من قائمة إلى قائمة أخرى:
مثال
استخدم الوظيفة extend() لإضافة list2 في نهاية القائمة list1:
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

ستكون النتيجة:
['a', 'b', 'c', 1, 2, 3] 
جربها بنفسك  مِن ملف list_concat3.py
 
دالةْ المَنشَأ list () للقائمة
مِن الممكن أيضاً استخدام دالةْ الإنشاءأو البناء , list() لإنشاء قائمة جديدة.
مثال
استخدام list(), دالةْ المَنشَأ لعمل قائمة:
thislist = list(("apple", "banana", "cherry")) # note the double round-brackets
print(thislist)

ستكون النتيجة:
['apple', 'banana', 'cherry'] 
جربها بنفسك  مِن ملف list_constructor.py
 
وظائف القائمة
يحتوي Python على مجموعة من الوظائف المضمنة التي يمكنك استخدامها في القوائم.

append()
تضيف عنصرا في نهاية القائمة
clear()
تُزيل جميع العناصر من القائمة
copy()
تُرجع نسخة من القائمة
count()
إرجاع عدد العناصر ذات قيمة معينة
extend()
إضافة عناصر قائمة (أو أي كائن iterable) ، إلى نهاية القائمة الحالية
index()
تُرجع قيمةْ الفهرس, لأول عنصر في القائمة ذات قيمة معينة
insert()
تُضيف عنصرا في القائمة في موضع محدد
pop()
تُزيل العنصر في الموضع المحدد
remove()
تُزيل العنصر ذو القيمة المحددة
reverse()
تعكس ترتيب العناصر في القائمة
sort()
تُرَتِّب العناصر في القائمة
 
اختبر نفسك مع التمارين
التمرين:
إطْبَعْ العنصر الثاني في القائمة fruits.
fruits = ["apple", "banana", "cherry"]
print(... )

الإجابة:
 print(fruits[1])

نماذج حول القوائم
اضغط هنا لتنزيلها أو تصفحها

المصفوفات في بايثون(Python Tuples)
Tuple
المصفوفة (tuple) هي مجموعة مرَتبة وغير قابلة للتغيير. 
في Python ، تتم كتابة المجموعات بأقواس دائرية.
مثال
إنشاء Tuple:
thistuple = ("apple", "banana", "cherry")
print(thistuple)

ستكون النتيجة:
('apple', 'banana', 'cherry') 
جربها بنفسك  مِن ملف tuple.py
 
الوصول إلى عناصر المصفوفة(Tuple)
يمكنك الوصول إلى عناصر ال tuple بالإشارة إلى رقم الفهرس ، داخل أقواس مربعة:
مثال
طباعة العنصر الثاني في المصفوفة:
thistuple = ("apple", "banana", "cherry")
print(thistuple[1])

ستكون النتيجة:
banana 
جربها بنفسك  مِن ملف tuple1.py

الفهرسة السلبية. Negative Indexing
تعني الفهرسة السلبية البدء من النهاية ، -1وتشير إلى العنصر الأخير ، -2 وتشير إلى العنصر ما قبل الأخير  وما إلى ذلك.
مثال
طباعة العنصر الأخير من المصفوفة:
thistuple = ("apple", "banana", "cherry")
print(thistuple[-1])

ستكون النتيجة:
cherry 
جربها بنفسك  مِن ملف tuple_negative_index.py

نطاق من الفهارِس(Indexes)
يمكنك تحديد نطاق من الفهارس عن طريق تحديد مكان بدء النطاق ومكان إنهاءه.
عند تحديد نطاق ، ستكون قيمة الإرجاع عبارة عن مجموعة جديدة بالعناصر المحددة.
مثال
إرجاع العنصر الثالث والرابع والخامس:
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])

ستكون النتيجة:
('cherry', 'orange', 'kiwi') 
جربها بنفسك  مِن ملف tuple_range.py
ملاحظة: سيبدأ البحث في الفهرس 2 (مشمول) وينتهي في الفهرس 5 (غير مشمول).
تذَكر أن قيمة الفهرس للعنصر الأول هو  0.

نطاق الفهارس السلبية
استخدِمْ الفهارس السالبة إذا كنت تريد بدء البحث من نهاية المجموعة:
مثال
يُرجع هذا المثال العناصر من الفهرس -4 (متضمن) إلى الفهرس -1 (غير متضمن)
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[-4:-1])

ستكون النتيجة:
('orange', 'kiwi', 'melon') 
جربها بنفسك  مِن ملف tuple_range_negative.py
  
تغيير قيم الصفوف (Tuple)
بمجرد إنشاء مصفوفة ، لا يمكنك تغيير قِيَمها. 
المصفوفات(tuples) هي غير قابلة للتغيير . فهي مِن الأنواع الغير قابلة للتغيير في بايثون مثل السلسلة النصية مثلا.
ولكن هناك حل بديل. يمكنك تحويل المصفوفة إلى قائمة، وتغيير القائمة، ثُمَّ تحويل القائمة مرة أخرى إلى مصفوفة.
مثال
قم بتحويل المصفوفة(tuple) إلى قائمة لتتمكن من تغييرها:
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

ستكون النتيجة:
("apple", "kiwi", "cherry") 
جربها بنفسك  مِن ملف tuple_change.py
 
عمل حلقة من خلال Tuple
يمكنك إجراء حلقة عبر عناصر المصفوفة باستخدام الحلقة for.
مثال
استخدام الحلقة للدوران حول العناصر وطباعة القيم:
thistuple = ("apple", "banana", "cherry")
for x in thistuple:
	print(x)

ستكون النتيجة:
apple
banana
cherry 
جربها بنفسك  مِن ملف tuple_loop.py
سوف تتعلم المزيد عن الحلقات for في فصل Python For Loops .
 
التحقق من وجود العنصر في ال tuple
لِمعرفةْ ما إذا كان عنصر معين موجودًا في المصفوفة ، استخدم الكلمة الأساسية in :
مثال
تحقق مما إذا كان العنصر "apple" موجودا في المصفوفة:
thistuple = ("apple", "banana", "cherry")
if "apple" in thistuple:
	print("Yes, 'apple' is in the fruits tuple")

ستكون النتيجة:
Yes, 'apple' is in the fruits tuple 
جربها بنفسك  مِن ملف tuple_in.py
 
طول المصفوفة (Tuple)
لِمعرفةْ عدد العناصر التي تحتوي عليها المصفوفة (tuple) ، استخدم الوظيفة len() :
مثال
طباعة عدد العناصر في المصفوفة:
thistuple = ("apple", "banana", "cherry")
print(len(thistuple))

ستكون النتيجة:
3 
جربها بنفسك  مِن ملف tuple_length.py
 
إضافة عناصر إلى المصفوفة
بمجرد إنشاء مصفوفة ، لا يمكنك إضافة عناصر إليها. Tuples غير قابلة للتغيير .
مثال
لا يمكنك إضافة عناصر إلى مصفوفة:
thistuple = ("apple", "banana", "cherry")
thistuple[3] = "orange" # This will raise an error
print(thistuple)

ستكون النتيجة:
Traceback (most recent call last):
  File "tuple_add.py", line 2, in 
    thistuple[3] = "orange" # This will raise an error
TypeError: 'tuple' object does not support item assignment 
جربها بنفسك  مِن ملف tuple_add.py
 
إنشاء Tuple يحتوي على عنصر واحد
لإنشاء مصفوفة تحتوي على عنصر واحد فقط ، يجب عليك إضافة فاصلة بعد العنصر ، وإلا فلن يتعرف عليها Python على أنها مصفوفة.
مثال
إنشاء tuple بعنصر واحد  ، تَذَكر الفاصلة:
thistuple = ("apple",)
print(type(thistuple))

#NOT a tuple
thistuple = ("apple")
print(type(thistuple))

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

 
جربها بنفسك  مِن ملف tuple_one_item.py
 
إزالة العناصر
ملاحظة: لا يمكنك إزالة العناصر الموجودة في المصفوفة.
المصفوفات غير قابلة للتغيير،لذا لا يمكنك إزالة العناصر منها، ولكن يمكنك حذف المصفوفة تمامًا:
مثال
باستخدام الكلمة del يمكن حذف الصفوف (tuple) تماما:
thistuple = ("apple", "banana", "cherry")
del thistuple
print(thistuple)#this will raise an error because the tuple no longer exists

ستكون النتيجة:
Traceback (most recent call last):
  File "tuple_del.py", line 3, in 
    print(thistuple) #this will raise an error because the tuple no longer exists
NameError: name 'thistuple' is not defined 
جربها بنفسك  مِن ملف tuple_del.py
 
ضم أو دمج مصفوفَتين(tuples)
لِضم أو جمع  مصفوفَتينت أو أكثر ، يمكنك استخدام العلامة + :
مثال
ضم أو دمج مصفوفَتين:
tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

ستكون النتيجة:
('a', 'b', 'c', 1, 2, 3) 
جربها بنفسك  مِن ملف tuple_concat.py
 
دالةْ المَنشأ tuple ()
من الممكن أيضًا استخدام دالةْ المَنشأ tuple () لعمل مصفوفة tuple.
مثال
استخدام دالةْ المَنشأ tuple () لعمل tuple:
thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)

ستكون النتيجة:
('apple', 'banana', 'cherry') 
جربها بنفسك  مِن ملف tuple3.py
 
وظائف المصفوفة(Tuple)
يحتوي Python على وظيفتين مدمجتين يمكنك استخدامهما في المصفوفات.

count()
إرجاع عدد المرات التي توجد فيها قيمة معينة في المصفوفة (tuple)
index()
تبحث في المصفوفة (tuple) عن قيمة معينة وتُرجع موضع المكان الذي تم العثور عليها فيه

 اختبر نفسك مع التمارين
التمرين:
اطْبع العنصر الأول في المصفوفة fruits.
fruits = ("apple", "banana", "cherry")
print( ...)

الإجابة:
print(fruits[0])

نماذج حول المصفوفات
اضغط هنا لتنزيلها أو تصفحها

المجموعات في بايثون(Python Sets)
المجموعة(Set)
المجموعة هي مجموعة غير مرَتبة وغير مفهرسة. 
في لغة بايثون ، تتم كتابة المجموعات بأقواس متعرِّجَة, {}.
مثال
 دعنا نقوم بإنشاء مجموعة:
thisset = {"apple", "banana", "cherry"}
print(thisset)

النتيجة:
{'cherry', 'apple', 'banana'} 
جربها بنفسك  مِن ملف set.py
ملاحظة: المجموعات غير مرَتبة ، لذا لا يمكنك التأكد من الترتيب الذي ستظهر به العناصر.
 
الوصول إلى العناصر 
لا يمكنك الوصول إلى العناصر في مجموعة بالإشارة إلى فهرس أو مفتاح.
ولكن يمكنك إجراء حلقة عبر عناصر المجموعة باستخدام الحلقة for  ، أو السؤال عما إذا كانت هناك قيمة معينة موجودة في المجموعة ، باستخدام الكلمة الأساسية in.
مثال
عمل حلقة عبر مجموعة وطباعة القيم:
thisset = {"apple", "banana", "cherry"}

for x in thisset:
	print(x)

النتيجة:
apple
cherry
banana
جربها بنفسك  مِن ملف set_loop.py

مثال
تحقق من وجود "banana" في المجموعة:
thisset = {"apple", "banana", "cherry"}

print("banana"in thisset)

النتيجة:
True 
جربها بنفسك  مِن ملف set_in.py
 
تغيير العناصر في المجموعة
بمجرد إنشاء مجموعة ، لا يمكنك تغيير عناصرها ، ولكن يمكنك إضافة عناصر جديدة.
 
إضافة عناصر إلى المجموعة
لإضافة عنصر واحد إلى مجموعة استخدم الوظيفة add() .
لإضافة أكثر من عنصر إلى مجموعة استخدم الوظيفة update() .
مثال
إضافة عنصر إلى مجموعة باستخدام الوظيفة add() :
thisset = {"apple", "banana", "cherry"}

thisset.add("orange")

print(thisset)

النتيجة:
{'cherry', 'orange', 'apple', 'banana'} 
جربها بنفسك  مِن ملف set_add.py

مثال
إضافة عدة عناصر إلى مجموعة باستخدام الوظيفة update() :
thisset = {"apple", "banana", "cherry"}

thisset.update(["orange", "mango", "grapes"])

print(thisset)

النتيجة:
{'grapes', 'banana', 'orange', 'apple', 'cherry', 'mango'} 
جربها بنفسك  مِن ملف set_update.py
 
 
معرفةْ طول المجموعة
لتحديد عدد العناصر الموجودة في المجموعة ، استخدم الدالة len().
مثال
معرفةْ عدد العناصر في مجموعة:
thisset = {"apple", "banana", "cherry"}

print(len(thisset))

ستكون النتيجة:
3 
جربها بنفسك  مِن ملف set_length.py
 
إزالةْ عنصر مِن المجموعة
لإزالةْ عنصر مِن مجموعة ، استخدم الوظيفة remove()أو discard().
مثال
إزالةْ "banana" باستخدام الوظيفة remove()
thisset = {"apple", "banana", "cherry"}

thisset.remove("banana")

print(thisset)

النتيجة:
{'cherry', 'apple'} 
جربها بنفسك  مِن ملف set_remove.py
ملاحظة: إذا لم يكن العنصر الذي تريد إزالته موجوداً، فإن remove() سَتُعطي  رسالةْ خطأ.

مثال
إزالة "banana" باستخدام الوظيفة discard()
thisset = {"apple", "banana", "cherry"}

thisset.discard("banana")

print(thisset)

النتيجة:
{'apple', 'cherry'} 
جربها بنفسك  مِن ملف set_discard.py
ملاحظة: إذا كان العنصر المراد إزالته غير موجود ، فإن الوظيفة discard () لن تؤدي  إلى حدوث خطأ.
يمكنك أيضًا استخدام الوظيفة pop() ، لإزالةْ عنصر ، لكن هذه الطريقة ستزيل العنصر الأخير . تذَكر أن المجموعات غير مرَتبة ، لذلك لن تعرف العنصر الذي ستتم إزالته.
قيمة الإرجاع للوظيفة pop() هي العنصر الذي تمت إزالته.
مثال
إزالة العنصر الأخير باستخدام الوظيفة pop() :
thisset = {"apple", "banana", "cherry"}

x = thisset.pop()

print(x)

print(thisset)

النتيجة:
cherry
{'banana', 'apple'} 
جربها بنفسك  مِن ملف set_pop.py
ملاحظة: المجموعات غير مرَتبة ، لذلك عند استخدام الوظيفة pop() ، فإنك لن تعرف العنصر الذي سوف تتم  إزالته.

مثال
تعمل  الوظيفة clear()  على إفراغ مجموعة:
thisset = {"apple", "banana", "cherry"}

thisset.clear()

print(thisset)

ستكون النتيجة:
set() 
جربها بنفسك  مِن ملف set_clear.py

مثال
ستقوم الكلمة الرئيسية del بحذف المجموعة تماما:
thisset = {"apple", "banana", "cherry"}

del thisset

print(thisset)

النتيجة:
Traceback (most recent call last):
  File "set_del.py", line 5, in 
    print(thisset) #this will raise an error because the set no longer exists
NameError: name 'thisset' is not defined 
جربها بنفسك  مِن ملف set_del.py
 
ضم أو دمج مجموعتين
هناك عدة طرق لِضم أو دمج مجموعتين أو أكثر في بايثون.
يمكنك استخدام الوظيفة union() التي تُرجع مجموعة جديدة تحتوي على جميع العناصر من كلتا المجموعتين ، أو الوظيفة update() التي تُدرج كل العناصر من مجموعة في أخرى:
مثال
تقوم الوظيفة union() بإرجاع مجموعة جديدة مع كل العناصر من كلتا المجموعتين:
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

النتيجة:
{'c', 'b', 'a', 2, 1, 3} 
جربها بنفسك  مِن ملف set_union.py

مثال
تقوم الوظيفة update () بإدراج العناصر الموجودة في set2 في set1:
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)
print(set1)

النتيجة:
{1, 'a', 'b', 2, 3, 'c'} 
جربها بنفسك  مِن ملف set_update2.py
ملاحظة: سيستبعد كل مِن union() و update () أي عناصر مكررة.

هناك طرق أخرى لِضم أو دمج مجموعتين وتحافظ فقط على التكرارات ، أو تستبعد التكرارات ، 
تحقق من القائمة الكاملة للوظائف المحددة المتعلقة بالمجموعة في أسفل هذه الصفحة.
 
دالة المَنشأ set()
مِن الممكن أيضًا استخدام دالة المَنشأ set () لإنشاء مجموعة.
مثال
استخدام دالة البناء أو الإنشاء set () لإنشاء مجموعة:
thisset = set(("apple", "banana", "cherry")) # note the double round-brackets
print(thisset)

النتيجة:
{'cherry', 'apple', 'banana'} 
جربها بنفسك  مِن ملف set2.py
 
الوظائف المتعلقة بالمجموعة(set methods)
يحتوي Python على مجموعة من الوظائف المتضمَنة التي يمكنك استخدامها في المجموعات.

add()
تُضيف عنصرا إلى المجموعة
clear()
تزيل جميع العناصر من المجموعة
copy()
تقوم بإرجاع نسخة من المجموعة
difference()
تقوم بإرجاع مجموعة تحتوي على الفرق بين اثنين أو أكثر من المجموعات
difference_update()
تقوم بإزالةْ العناصر الموجودة في هذه المجموعة  و الموجودة أيضا في مجموعة أخرى معينة
discard()
تقوم بإزالة العنصر المحدد
intersection()
تقوم بإرجاع مجموعة ، و هي تقاطع المجموعتين, أي العناصر المشتركة بينهما
intersection_update()
تقوم بإزالة العناصر الموجودة في هذه المجموعة غير الموجودة في مجموعة(أو مجموعات أخرى محددة)
isdisjoint()
إرجاع ما إذا كانت مجموعتان بينهما تقاطع أم لا, يعني عناصر مشتركة
issubset()
إرجاع ما إذا كانت مجموعة أخرى تحتوي هذه المجموعة أم لا
issuperset()
إرجاع ما إذا كانت هذه المجموعة تحتوي على مجموعة أخرى أم لا
pop()
تقوم بإزالة عنصر من المجموعة
remove()
تقوم بإزالة عنصرا محددا
symmetric_difference()
تقوم بإرجاع مجموعة مع الاختلافات المتماثلة بين مجموعتين. أي مجموعة تحتوي على العناصر غير المشتركة
symmetric_difference_update()
تقوم بإدراج الاختلافات المتماثلة بين هذه المجموعة و مجموعة أخرى
union()
تقوم بإرجاع مجموعة تحتوي على عناصر المجموعات الأخرى
update()
تقوم بتحديث مجموعة مع اتحاد هذه المجموعة وغيرها
 
اختبر نفسك مع التمارين
التمرين:
تحقق من وجود "apple" في المجموعة fruits.
fruits = {"apple", "banana", "cherry"}
if "apple" ... fruits:
	print("Yes, apple is a fruit!")

الإجابة:
 fruits = {"apple", "banana", "cherry"}
if "apple"  in fruits:
	print("Yes, apple is a fruit!")

نماذج حول المجموعات
اضغط هنا لتصفحها

القواميس في بايثون
القاموس(dictionary)
القاموس هو مجموعة غير مرَتبة وقابلة للتغيير ومفهرسة. 
تتم كتابة القواميس في بايثون بأقواس معقوفة {}, ولديها مفاتيح وقيَم.
مثال
إنشاء وطباعة قاموس:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

النتيجة:
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964} 
جربها بنفسك  مِن ملف dictionary.py
 
الوصول إلى العناصر
يمكنك الوصول إلى عناصر القاموس بالإشارة إلى قيمةْ المفتاح، داخل الأقواس المربعة:
مثال
الحصول على قيمة مفتاح "model":
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
x = thisdict["model"]
print(x)

ستكون النتيجة:
Mustang 
جربها بنفسك  مِن ملف dictionary_access.py

هناك أيضاً وظيفة تُسمى get() التي ستعطيك نفس النتيجة:
مثال
الحصول على قيمة مفتاح "model":
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
x = thisdict.get("model")
print(x)

ستكون النتيجة:
Mustang 
جربها بنفسك  مِن ملف dictionary_get.py
  
تغيير القيم
يمكنك تغيير قيمةْ عنصر معين بالإشارة إلى اسم المفتاح الخاص به:
مثال
تغيير "year" إلى 2018:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict["year"] = 2018
print(thisdict)

ستكون النتيجة:
{'brand': 'Ford', 'model': 'Mustang', 'year': 2018} 
جربها بنفسك  مِن ملف dictionary_change.py
 
حلقة من خلال القاموس
يمكنك إجراء حلقة من خلال قاموس باستخدام الحلقة for.
عند عمل حلقة مِن خلال القاموس ، تكون القيم التي سنحصل عليها هي مفاتيح القاموس ، ولكن هناك طرق لإرجاع القيم أيضًا.
مثال
طباعة جميع أسماء المفاتيح في القاموس ، واحدًا تلو الآخر:
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
for x in thisdict:
	print(x)

النتيجة:
brand
model
year 
جربها بنفسك  مِن ملف dictionary_loop.py

مثال
طباعة جميع القيم في القاموس واحدة تلو الأخرى:
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
for x in thisdict:
	print(thisdict[x])

النتيجة:
Ford
Mustang
1964 
جربها بنفسك  مِن ملف dictionary_loop2.py

مثال
يمكنك أيضًا استخدام الوظيفة values() لإرجاع قيَم القاموس:
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
for x in thisdict.values():
	print(x)

النتيجة:
Ford
Mustang
1964 
جربها بنفسك  مِن ملف dictionary_loop_values.py

مثال
حلقة من خلال كل من المفاتيح والقيم ، وذلك باستخدام الوظيفة items():
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
for x, y in thisdict.items():
	print(x, y)

النتيجة:
brand Ford
model Mustang
year 1964 
جربها بنفسك  مِن ملف dictionary_loop_items.py
 
التحقق من وجود مفتاح في القاموس
لِمعرفةْ ما إذا كان مفتاح معين موجود في القاموس ، استخدم الكلمة الرئيسية in:
مثال
تحقق مما إذا كان "model" موجودًا في القاموس:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
if "model" in thisdict:
	print("Yes, 'model' is one of the keys in the thisdict dictionary")

ستكون النتيجة:
Yes, 'model' is one of the keys in the thisdict dictionary 
جربها بنفسك  مِن ملف dictionary_in.py
 
طول القاموس
لتحديد عدد العناصر (العنصر هنا يعني المفتاح والقيمة معاً) في القاموس ، استخدم الوظيفة len() .
مثال
طباعة عدد العناصر في القاموس:
thisdict ={
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

print(len(thisdict))

ستكون النتيجة:
3 
جربها بنفسك  مِن ملف dictionary_length.py
 
إضافة عناصر إلى القاموس
تتم إضافة عنصر إلى القاموس باستخدام مفتاح  جديد وإعطاء قيمة له:
مثال
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict["color"] = "red"
print(thisdict)

النتيجة:
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'} 
جربها بنفسك  مِن ملف dictionary_add.py
 
إزالة العناصر مِن القاموس
هناك عدة طرق لإزالة العناصر من القاموس:
مثال
تقوم وظيفة pop() بإزالة العنصر باستخدام اسم المفتاح المحدد:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.pop("model")
print(thisdict)

النتيجة:
{'brand': 'Ford', 'year': 1964} 
جربها بنفسك  مِن ملف dictionary_pop.py

مثال
تقوم الوظيفة popitem() بإزالةْ آخر عنصر مدْرج في القاموس.
(أما في الإصدارات قبل 3.7 ، تتم إزالة عنصر عشوائي بدلاً من ذلك):
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.popitem()
print(thisdict)

النتيجة:
{'brand': 'Ford', 'model': 'Mustang'} 
جربها بنفسك  مِن ملف dictionary_popitem.py

مثال
تقوم الكلمة الرئيسية del بإزالة العنصر بلإشارة إلى اسم المفتاح المحدد:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
del thisdict["model"]
print(thisdict)

النتيجة:
{'brand': 'Ford', 'year': 1964} 
جربها بنفسك  مِن ملف dictionary_del2.py

مثال
و باستخدام الكلمة del يمكن أيضا حذف القاموس تماما:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
del thisdict
print(thisdict) #this will cause an error because "thisdict" no longer exists.

النتيجة:
Traceback (most recent call last):
  File "dictionary_del3.py", line 7, in 
NameError: name 'thisdict' is not defined
جربها بنفسك  مِن ملف dictionary_del3.py

مثال
تقوم الوظيفة clear() بإفراغ القاموس:
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.clear()
print(thisdict)

ستكون النتيجة:
{} 
جربها بنفسك  مِن ملف dictionary_clear.py
 
نَسخ القاموس
لا يمكنك نَسخ القاموس ببساطة عن طريق كتابة dict2 = dict1 ، لأن: dict2 سيكون فقط إشارة إلى dict1 ، 
و أي  تغييرات يتم إجراؤها في dict1 تلقائيا سيتم إجراءها في dict2.
يعني بهاذه الطريقة, فإن dict1 و dict2 يُعتبران متغيران يشيران إلى نفس الكائن.
و لكن هناك طرق لعمل نسخة ، إحدى الطرق هي استخدام وظيفة القاموس المتضمنة copy().
مثال
إنشاء نسخة من قاموس باستخدام الوظيفة copy():
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
mydict = thisdict.copy()
print(mydict)

النتيجة:
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964} 
جربها بنفسك  مِن ملف dictionary_copy.py

هناك طريقة أخرى لعمل نسخة وهي استخدام الوظيفة المضمنة dict(). و هي نفسها وظيثةْ الإنشاء للقاموس.
مثال
عمل نسخة من القاموس باستخدام الدالة dict() :
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
mydict = dict(thisdict)
print(mydict)

النتيجة:
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964} 
جربها بنفسك  مِن ملف dictionary_copy2.py
 
القواميس المتداخلة
يمكن أن يحتوي القاموس أيضًا على العديد من القواميس الأخرى، وهذا ما يسمى بالقواميس المتداخلة.
مثال
إنشاء قاموس يحتوي على ثلاثة قواميس:
myfamily = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}

print(myfamily)

النتيجة:
{'child1': {'name': 'Emil', 'year': 2004}, 
'child2': {'name': 'Tobias', 'year': 2007}, 
'child3': {'name': 'Linus', 'year': 2011}} 
جربها بنفسك  مِن ملف dictionary_nested.py

أو ، إذا كنت تريد دمج ثلاثة قواميس موجودة مُسبقا بالفعل, في قاموس:
مثال
إنشاء ثلاثة قواميس ، ثُمَّ إنشاء قاموس واحد من شأنِه أن يحتوي على القواميس الثلاثة الأخرى:
child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}

myfamily = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}
print(myfamily)

النتيجة:
{'child1': {'name': 'Emil', 'year': 2004}, 
'child2': {'name': 'Tobias', 'year': 2007}, 
'child3': {'name': 'Linus', 'year': 2011}} 
جربها بنفسك  مِن ملف dictionary_nested2.py
 
دالةْ المَنشأ dict()
مِن الممكن أيضاً استخدام دالة الإنشاء dict() لإنشاء قاموس جديد:
مثال
thisdict = dict(brand="Ford", model="Mustang", year=1964)
# note that keywords are not string literals
# note the use of equals rather than colon for the assignment
print(thisdict)

النتيجة:
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964} 
جربها بنفسك  مِن ملف dictionary_dict.py
 
وظائف القاموس
يحتوي Python على مجموعة من الوظائف المضمنة التي يمكنك استخدامها في القواميس.

clear()
تقوم بإزالة جميع العناصر من القاموس
copy()
تقوم بعمل نسخة من القاموس
fromkeys()
تقوم بإرجاع قاموس مع المفاتيح والقيمة المحددة
get()
تقوم بإرجاع قيمة المفتاح المحدد
items()
تقوم بإرجاع قائمة تحتوي على الصفوف (tuple) لكل زوج مِن المفتاح و القيمة 
keys()
تقوم بإرجاع قائمة تحتوي على مفاتيح القاموس 
pop()
تقوم بإزالة العنصر صاحب المفتاح المحدد
popitem()
تقوم بإزالة آخر زوج مدْرج من مفتاح و قيمة  
setdefault()
تقوم بإرجاع قيمة المفتاح المحدد. إذا لم يكن المفتاح موجودا: تقوم بإدخال المفتاح ، مع القيمة المحددة
update()
تقوم بتحديث القاموس مع أزواج المفاتيح و القيم المحددة
values()
تقوم بإرجاع قائمة تحتوي على جميع القيم في القاموس
 
اختبر نفسك مع التمارين
التمرين:
استخدم الوظيفة get لِطباعةْ قيمةْ مفتاح "model" في القاموس car.
car ={
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print( ...)

الإجابة:
x= car.get("model")
print(x)

نماذج حول القواميس
اضغط هنا لتنزيل ها أو تصفحها

أسلوب الشرط في بيثون, If ... Else
أسلوب الشرط في Python وعبارةْ If
بايثون يدعم الشروط المنطقية المعتادة من الرياضيات:
• يساوي: a == b
• لا يساوي: a!= b
• أقل من: a < b
• أقل من أو يساوي: a <= b
• أكبر من: a > b
• أكبر من أو يساوي: a >= b
يمكن استخدام هذه الشروط بعدة طرق ، وأكثرها شيوعًا في "عبارات if" والحلقات.
تتم كتابة عبارة "if" باستخدام الكلمة الأساسية if .
مثال
استخدام الشرط if:
a = 33
b = 200
if b > a:
	print("b is greater than a")

ستكون النتيجة:
b is greater than a 
جربها بنفسك  مِن ملف if2.py
في هذا المثال ، نستخدم متغيرين ، a و b ، يستخدمان كجزء من أسلوب if لاختبار ما إذا كان b أكبر من a. 
بما أن a هو 33 ، و b هو 200 ، فإننا نعلم أن 200 أكبر من 33 ، وهكذا نَطْبَع جواب شرط أن "b أكبر من a".

الإزاحة(Indentation)
يعتمد بايثون على المسافة البادئة (المسافة البيضاء في بداية السطر) لتحديد النطاق في الكود. 
غالبًا ما تستخدم لغات البرمجة الأخرى الأقواس المتعرجة لهذا الغرض.
البعض يستخدم المسافة كوسيلة للإزاحة(indentation), و لكن نحن نفَضِّل استخدام التاب لهذا الأمر.
مثال
إذا كان جواب العبارة if، بدون مسافة بادئة (ستعطي رسالةْ خطأ):
a = 33
b = 200
if b > a:
print("b is greater than a") # you will get an error

النتيجة:
  File "if_error.py", line 4
    print("b is greater than a")
        ^
IndentationError: expected an indented block 
جربها بنفسك  مِن ملف if_error.py
 
elif
الكلمة الرئيسية elif هي طريقة pythons للقول "إذا لم تكن الشروط السابقة صحيحة ، فجرب هذا الشرط".
مثال
a = 33
b = 33
if b > a:
	print("b is greater than a")
elif a == b:
	print("a and b are equal")

ستكون النتيجة:
a and b are equal 
جربها بنفسك  مِن ملف if_elif.py
في هذا المثال a يساوي b ، وبالتالي فإن الشرط الأول ليس صحيحا ، ولكن شرط elif صحيح ، لذلك نطْبع على الشاشة أنّ "a and b are equal".
 
else
الكلمة الرئيسية else تستوعب أي شيء لا يتم التجاوب معه من قِبَل الشروط السابقة.
مثال
a = 200
b = 33
if b > a:
	print("b is greater than a")
elif a == b:
	print("a and b are equal")
else:
	print("a is greater than b")

ستكون النتيجة:
a is greater than b 
جربها بنفسك  مِن ملف if_else.py
في هذا المثال ، a أكبر من b ، وبالتالي فإن الشرط الأول ليس صحيحًا ، وكذلك شرط elif ليس صحيحًا ، لذلك نذهب إلى شرط else ونطبع على الشاشة "a is greater than b".

يمكنك أيضًا استخدام elseبدون elif:
مثال
a = 200
b = 33
if b > a:
	print("b is greater than a")
else:
	print("b is not greater than a")

ستكون النتيجة:
b is not greater than a 
جربها بنفسك  مِن ملف if_else2.py
 
if و جوابها على سطر واحد
إذا كان لديك شرط واحد فقط لتنفيذه ، يمكنك وضع جوابها على نفس سطر عبارةْ if.
مثال
عبارةْ if و جوابها على سطر واحد:
a = 200
b = 33

if a > b: print("a is greater than b")

ستكون النتيجة:
a is greater than b
جربها بنفسك  مِن ملف if_short.py
 
كتابةْ if و else على سطر واحد
إذا كان لديك عبارة واحدة فقط لتنفيذها ، واحدة لـ if وواحدة لـ else ، فيمكنك وضعها جميعًا في نفس السطر:
مثال
if و else على سطر واحد:
a = 2
b = 330
print("A") if a > b else print("B")

ستكون النتيجة:
B 
جربها بنفسك  مِن ملف if_else_short.py
تُعرف هذه التقنية بالعوامل الثلاثية(Ternary Operators,) أو التعبيرات الشرطية .

يمكنك أيضًا استعمال  عبارةْ else مرّات متعددة في نفس السطر:
مثال
عبارةْ if else ، مع 3 شروط في سطر واحد:
a = 330
b = 330
print("A") if a > b else print("=") if a == b else print("B")

ستكون النتيجة:
= 
جربها بنفسك  مِن ملف if_else_short2.py
 
and
 b and c > a:
	print("Both conditions are True")

ستكون النتيجة:
Both conditions are True 
جربها بنفسك  مِن ملف if_and.py
 
or
الكلمة الرئيسية or هي عامل منطقي ، ويتم استخدامها لدمج العبارات الشرطية:
مثال
اختبار ما إذا كانت aأكبر من b، أو إذا كانت a أكبر من c:
a = 200
b = 33
c = 500
if a > b or a > c:
	print("At least one of the conditions is True")

ستكون النتيجة:
At least one of the conditions is True 
جربها بنفسك  مِن ملف if_or.py
 
f متداخلة (Nested If)
يمكن أن يكون لديك عبارات if داخل عبارات if أخرى، وهذا ما يسمى بتعليمات if المتداخلة  .
مثال
x = 41
if x > 10:
	print("Above ten,")
	if x > 20:
		print("and also above 20!")
	else:
		print("but not above 20.")

ستكون النتيجة:
Above ten,
and also above 20! 
جربها بنفسك  مِن ملف if_nested.py
 
عبارةْ التمرير(pass Statement)
لا يمكن أن تكون عبارات if فارغة, اي بدون جواب، 
ولكن إذا كان لديك لسبب ما عبارة if لا تحتوي على جواب ، فَضَع العبارة pass مكان الجواب لتجنب حدوث خطأ.
مثال
a = 33
b = 200
if b > a:
	pass

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

جربها بنفسك  مِن ملف if_pass.py
 
اختبر نفسك مع التمارين
التمرين:
قم بطباعةْ "Hello World" إذا كان aأكبر من b.
a = 50
b = 10
...a...b... 
	print("Hello World")

الإجابة:
 a = 50
b = 10
if a > b:
	print("Hello World")

 نماذج حول أسلوب الشرط
اضغط هنا لتصفحها

الحلقة while في بايثون (While Loops)
حلقات بايثون
يوجد في بايثون نوعَيْن مِن الحلقات:
• الحلقة while (while loops)
• الحلقة for (for loops)
 
الحلقة while
باستخدام حلقة while ، يمكننا تنفيذ مجموعة من العبارات طالما أن الشرط صحيحا.
مثال
طباعة i طالما i أقل من 6:
i = 1
while i < 6:
	print(i)
	i += 1

ستكون النتيجة:
1
2
3
4
5 
جربها بنفسك  مِن ملف while.py
ملاحظة: تذَكر زيادة قيمةْ i ، وإلا ستستمر الحلقة إلى الأبد.
تتطلب حلقة while أن تكون المتغيرات ذات الصلة جاهزة، 
في هذا المثال احتجنا إلى عمل متغير أسميناه i ، والذي قمنا بتعديل قيمته بزيادةْ 1 عليه في كل دورة مِن الحلقة.
 
عبارةْ break لِكسر الحلقة(break Statement)
باستخدام العبارة break يمكننا إيقاف الحلقة حتى إذا كان شرط while صحيحًا:
مثال
الخروج مِن الحلقة عندما يكون i تُساوي 3:
i = 1
while i < 6:
	print(i)
	if i == 3:
		break
	i += 1

ستكون النتيجة:
1
2
3 
جربها بنفسك  مِن ملف while_break.py
  
عبارة continue لمواصلةْ الحلقة(continue Statement)
مع العبارة continue يمكننا إيقاف الدورة الحالية ، والاستمرار في الدورات التالية:
مثال
الإستمرار إلى التكرار التالي إذا كانت i تُساوي 3:
i = 0
while i < 6:
	i += 1
	if i == 3:
		continue
	print(i)

ستكون النتيجة:
1
2
4
5
6 
جربها بنفسك  مِن ملف while_continue.py
 
العبارة else (else Statement)
باستخدام العبارة else يمكننا تشغيل كتلة من التعليمات البرمجية مرة واحدة عندما الشرط في الحلقة لم يعد صحيحاً:
مثال
طباعة رسالة بمجرد أن يكون الشرط false:
i = 1
while i < 6:
	print(i)
	i += 1
else:
	print("i is no longer less than 6")

ستكون النتيجة:
1
2
3
4
5
i is no longer less than 6 
جربها بنفسك  مِن ملف while_else.py
 
اختبر نفسك مع التمارين
التمرين:
اطبع iما دام iأقل من 6.
i = 1
...i <6...
	print(i)
	i += 1

الإجابة:
i = 1
while i <6:
	print(i)
	i += 1

نماذج حول الحلقة while
اضغط هنا لتتصفحها

الحلقة for في بايثون (For Loop)
الحلقة for في بايثون
يتم استخدام الحلقة for للتكرار عبر أي تسلسل 
إما قائمة(list) أو مصفوفة(tuple) أو قاموس(dictionary) أو مجموعة(set) أو سلسلة نصِّيَّة(string).
هذا أقل شبها  بالكلمة الرئيسية for في لغات البرمجة الأخرى ، 
ويعمل أكثر مثل طريقة التكرار كما هو موجود في لغات البرمجة الأخرى الموجهة للكائنات(object-orientated programming ).
باستخدام حلقة for ، يمكننا تنفيذ مجموعة من العبارات ، مرة واحدة لكل عنصر في القائمة(list) ، أو tuple ، أو set ، إلخ.
مثال
طباعة كل فاكهة موجودة في قائمة الفاكهة:
fruits = ["apple", "banana", "cherry"]
forx in fruits:
	print(x)

ستكون النتيجة:
apple
banana
cherry 
جربها بنفسك  مِن ملف for.py
لا تتطلب حلقة for متغير و تعيينه مسبقا, كما كان الحال مع الحلقة while.
 
حلقة من خلال سلسلة نصِّيَّة(string)
حتى السلاسل النصِّية هي كائنات قابلة للتكرار ، فهي تحتوي على سلسلة من الأحرف:
مثال
حلقة من خلال الحروف في كلمة "banana":
for x in "banana":
	print(x)

ستكون النتيجة:
b
a
n
a
n
a 
جربها بنفسك  مِن ملف for_string.py
 
عبارةْ break لِكسر الحلقة(break Statement)
باستخدام العبارة break ، يمكننا إيقاف الحلقة قبل أن تمر عبر جميع العناصر:
مثال
الخروج من الحلقة عندما xتكون "banana":
fruits = ["apple", "banana", "cherry"]
for x in fruits:
	print(x)
	if x == "banana":
		break

ستكون النتيجة:
apple
banana 
جربها بنفسك  مِن ملف for_break.py

مثال
الخروج من الحلقة عندما x تكون "banana" ، لكن هذه المرة يكون كسر الحلقة قبل الطباعة:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
	if x == "banana":
		break
	print(x)

ستكون النتيجة:
apple 
جربها بنفسك  مِن ملف for_break2.py
  
عبارةْ continue لمواصلةْ الحلقة(continue Statement)
مع عبارة continue يمكننا إيقاف الدورة الحالية من الحلقة، ومتابعة الدورات التالية:
مثال
لا تطبعْ banana:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
	if x == "banana":
		continue
	print(x)

ستكون النتيجة:
apple
cherry 
جربها بنفسك  مِن ملف for_continue.py
 
الدالة range() 
لِعمل حلقة خلال مجموعة من التعليمات البرمجية لعدد محدد من المرات ، يمكننا استخدام الدالة range () 
تقوم الدالة range() بإرجاع تسلسل من الأرقام، بدءاً من 0 بشكل افتراضي، و الزيادة بمقدار 1 (افتراضياً)، والإنتهاء عند رقم محدد.
مثال
استخدام الدالة range ():
for x in range(6):
	print(x)

ستكون النتيجة:
0
1
2
3
4
5 
جربها بنفسك  مِن ملف for_range.py
لاحظْ أن range (6) ليس قيمًا من 0 إلى 6 ، ولكنه القيم من 0 إلى 5.
يتم جعل القيمة الافتراضية للدالة range () 0 كقيمة بداية ، 
ولكن من الممكن تحديد قيمة البداية عن طريق إضافة معامل: 
range (2 ، 6) ، مما يعني القيم من 2 إلى 6 (ولكن لا تشمل 6).
مثال
استخدام معامل البداية(start parameter):
for x in range(2, 6):
	print(x)

ستكون النتيجة:
2
3
4
5 
جربها بنفسك  مِن ملف for_range2.py

تقوم الدالة range() لزيادة التسلسل بشكل افتراضي، بمقدار 1 ، 
ومع ذلك فمن الممكن تحديد قيمة الزيادة بإضافة معامل ثالث: 
range (2 ، 30 ، 3), وبذلك تكون قيمةْ الزيادة تُسَاوي 3.
مثال
زيادة التسلسل بالعدد 3 (الافتراضي هو 1):
for x in range(2, 30, 3):
	print(x)

ستكون النتيجة:
2
5
8
11
14
17
20
23
26
29 
جربها بنفسك  مِن ملف for_range3.py
 
العبارة else بعد الحلقة For 
الكلمة else في الحلقة for تحدد كتلة من التعليمات البرمجية ليتم تنفيذها عندما تكون الحلقة قد انتهت:
مثال
طباعة جميع الأرقام من 0 إلى 5 ، وطباعة رسالة عندما تكون الحلقة قد انتهت:
for x in range(6):
	print(x)
else:
	print("Finally finished!")

ستكون النتيجة:
0
1
2
3
4
5
Finally finished! 
جربها بنفسك  مِن ملف for_else.py
 
الحلقات المتداخلة
الحلقة المتداخلة هي حلقة داخل حلقة.
سيتم تنفيذ "الحلقة الداخلية" مرة واحدة لكل تكرار لـ "الحلقة الخارجية":
يعني يتم تنفيذ الحلقة الداخلية كلها, عند كل دورة للحلقة الخارجية.
مثال
طباعة كل صفة لكل فاكهة:
adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]
for x in adj:
	for y in fruits:
		print(x, y)

ستكون النتيجة:
red apple
red banana
red cherry
big apple
big banana
big cherry
tasty apple
tasty banana
tasty cherry 
جربها بنفسك  مِن ملف for_nested.py
 
عبارةْ pass للتمرير(pass Statement)
pass معناها أنك تقول لبايثون, لا تفعل شيئا.
الحلقات forلا يمكن أن تكون  فارغة ، 
ولكن إذا كان لديك لسبب ما حلقة for بدون محتوى ، فَضَعْ العبارة pass لتجنب حدوث خطأ.
مثال
for x in [0, 1, 2]:
	pass

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

جربها بنفسك  مِن ملف for_pass.py
 
اختبر نفسك مع التمارين
التمرين:
إعمل حلقة مِن نوع for 
مِن خلال العناصر الموجودة في القائمة fruits.
fruits = ["apple", "banana", "cherry"]
... x ... fruits ...
	print(x)

الإجابة:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
	print(x)

نماذج حول الحلقة for
اضغط هنا لتصفحها

الدوال أو الوظائف في بايثون
الدالة عبارة عن كتلة من التعليمات البرمجية يتم تشغيلها فقط عند استدعائها.
يمكنك تمرير البيانات ، المعروفة باسم المعاملات أو الوسائط، إلى الدالة.
يمكن للدالة إرجاع البيانات كنتيجة.
 
إنشاء دالة
في Python يتم إنشاء الدالة باستخدام الكلمة الرئيسية def :
مثال
def my_function():
	print("Hello from a function")
 
استدعاء الدالة أو الوظيفة
لاستدعاء دالة ، استخدم اسم الدالة متبوعًا بأقواس(parenthesis):
مثال
def my_function():
	print("Hello from a function")

my_function()

ستكون النتيجة:
Hello from a function 
جربها بنفسك  مِن ملف function.py
 
المعامِلات أو الوسائط(Arguments)
يمكن تمرير المعلومات إلى الدالة كَوسائط.
يتم تحديد الوسيطات بعد اسم الوظيفة ، داخل الأقواس(parenthesis). 
يمكنك إضافة العديد من الوسائط كما تريد ، فقط افصل بينها بفاصلة.
المثال التالي له دالة ذات وسيطة واحدة (fname). 
عندما يتم استدعاء الدالة ، نقوم بتمرير الاسم الأول (first name)، والذي يتم استخدامه داخل الدالة لطباعة الاسم الكامل:
مثال
def my_function(fname):
	print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")

ستكون النتيجة:
Emil Refsnes
Tobias Refsnes
Linus Refsnes 
جربها بنفسك  مِن ملف function_param.py
غالبًا ما يتم اختصار arguments إلى args في وثائق Python.
  
معامِلات أَم وسائط؟
يمكن استخدام المصطلحان المعامِل  والوسيطة لنفس الشيء: المعلومات التي يتم تمريرها إلى دالة.
من منظور الدالة:
المعامِل هو المتغير المُدْرج داخل الأقواس في تعريف الدالة.
الوسيطة هي القيمة التي يتم تمريرها إلى الدالة عند استدعائها.
 
عدد الوسائط(Arguments)
بشكل افتراضي ، يجب استدعاء الدالة بالعدد الصحيح من الوسائط. 
بمعنى أنه إذا كانت وظيفتك تتوقع وسيطتين ، فعليك استدعاء الدالة باستخدام وسيطتين ، وليس أكثر وليس أقل.
مثال
تتوقع هذه الوظيفة وسيطين ، وتحصل على وسيطين:
def my_function(fname, lname):
	print(fname + " " + lname)

my_function("Emil", "Refsnes")

ستكون النتيجة:
Emil Refsnes 
جربها بنفسك  مِن ملف function_args_n.py
إذا حاولت استدعاء الدالة باستخدام وسيط واحد أو ثلاثة وسائط ، فستحصل على خطأ:
مثال
تتوقع هذه الوظيفة وسيطتين ، ولكنها تحصل على وسيط واحد فقط:
def my_function(fname, lname):
	print(fname + " " + lname)

my_function("Emil")

ستكون النتيجة:
Traceback (most recent call last):
  File "function_args_error.py", line 4, in 
    my_function("Emil")
TypeError: my_function() missing 1 required positional argument: 'lname'
جربها بنفسك  مِن ملف function_args_error.py

Arbitrary Arguments, *args 
الوسائط العشوائية, *args
إذا كنت لا تعرف عدد الوسائط التي سيتم تمريرها إلى الدالة الخاصة بك، أضف * قبل اسم المعامِل في تعريف الدالة.
بهاذه الطريقة ، ستتلقى الدالة مجموعة من الوسائط (tuple of arguments)، ويمكنها الوصول إلى العناصر وفقًا لذلك:
مثال
إذا كان عدد الوسائط غير معروف ، أضف *قبل اسم المعامِل:
def my_function(*kids):
	print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")

ستكون النتيجة:
The youngest child is Linus 
جربها بنفسك  مِن ملف function_args.py
غالبًا ما يتم اختصار الوسائط العشوائية إلى * args في وثائق Python.
 
الوسائط الرئيسية أو المُعَرَّفة(Keyword Arguments)
يمكنك أيضًا تمرير وسيطات باستخدام طريقة key = value .
و بهاذه الطريقة لا يهم ترتيب الوسائط.
مثال
def my_function(child3, child2, child1):
	print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

ستكون النتيجة:
The youngest child is Linus 
جربها بنفسك  مِن ملف function_kwargs.py
غالبًا ما يتم اختصار عبارة Keyword Arguments إلى kwargs في وثائق Python.
 
 Arbitrary Keyword Arguments, **kwargs
وسائط الكلمات الرئيسية العشوائية ، ** kwargs
إذا كنت لا تعرف عدد وسيطات الكلمات الأساسية(keyword arguments) التي سيتم تمريرها إلى وظيفتك ، فقم بإضافة نجمتين: **قبل اسم المعامِل في تعريف الوظيفة.
بهاذه الطريقة ستتلقى الوظيفة قاموسًا من الوسائط ، ويمكنها الوصول إلى العناصر وفقًا لذلك:
مثال
إذا كان عدد وسيطات الكلمات الرئيسية (keyword arguments)غير معروف ، فقم بإضافة **قبل اسم المعامِل:
def my_function(**kid):
	print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

ستكون النتيجة:
His last name is Refsnes 
جربها بنفسك  مِن ملف function_kwargs_n.py
غالبًا ما يتم اختصار وسيطات الكلمات الرئيسية العشوائية إلى ** kwargs في وثائق Python.
 
القيمة الافتراضية للمعامِل
يوضح المثال التالي كيفية استخدام قيمة معامِل افتراضي.
إذا استدعينا الدالة بدون وسيط ، فإنها تستخدم القيمة الافتراضية:
مثال
def my_function(country = "Norway"):
	print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

ستكون النتيجة:
I am from Sweden
I am from India
I am from Norway
I am from Brazil 
جربها بنفسك  مِن ملف function_param2.py
 
تمرير القائمة في الدالة كوسيطة(Argument)
يمكنك تمرير أي نوع مِن أنواع البيانات كوسيطة إلى وظيفة (سلسلة نصِّيَّة، رقم ، قائمة ، قاموس إلخ.) ، وسيتم التعامل معها على أنها نفس نوع البيانات داخل الوظيفة.
على سبيل المثال ، إذا قمت بجعل قائمة كوسيطة، فستظل قائمة عندما تصل إلى استدعاء الوظيفة:
مثال
def my_function(food):
	for x in food:
		print(x)

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

my_function(fruits)

ستكون النتيجة:
apple
banana
cherry 
جربها بنفسك  مِن ملف function_param3.py
 
إرجاع القيم في الدالة
للسماح للدالة بإرجاع قيمة ، استخدم العبارة return :
مثال
def my_function(x):
	return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

ستكون النتيجة:
15
25
45
جربها بنفسك  مِن ملف function_return.py
 
عبارة التمرير(pass Statement)
لا يمكن أن يكون محتوى الوظائف فارغا ، ولكن إذا كان لديك لسبب ما تعريف وظيفة بدون محتوى ، فضع فيها عبارة pass لتجنب حدوث خطأ.
مثال
def myfunction():
	pass

# إنشاء دالة فارغة مثل هذه, كان سيؤدي إلى حدوث خطأ مِن دون عبارة التمرير.

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

جربها بنفسك  مِن ملف function_pass.py
 
التكرار أو العودية للدالة(Recursion)
يقبل Python أيضًا تكرار الوظيفة ، مما يعني أن الوظيفة المحددة يمكنها استدعاء نفسها.
التكرار(Recursion) هو مفهوم رياضي وبرمجي شائع. 
هذا يعني أن الوظيفة تستدعي نفسها. هذا له فائدة بمعنى أنه يمكنك تكرار البيانات للوصول إلى نتيجة.
يجب أن يكون المطور حريصًا جدًا في التعامل مع العودية(Recursion ) 
حيث قد يكون من السهل جدًا الانزلاق إلى كتابة وظيفة لا تنتهي أبدًا ، أو وظيفة تستخدم كميات زائدة من الذاكرة أو طاقة المعالِج. 
ومع ذلك ، عند كتابة العودية بشكل صحيح ، يمكن أن تكون طريقة فعالة للغاية وأنيقة من الناحية الحسابية للبرمجة.
في هذا المثال ، tri_recursion () هي دالة قمنا بإنشائها لتستدعي نفسها ("recurse"). 
نستخدم المتغير k كوسيط للدالة ، والتي تنخفض قيمته ( -1 ) في كل مرة تُستدعى الدالة  فيها. 
تنتهي العودية(Recursion) عندما لا تكون قيمةْ k أكبر من 0 (أي عندما تكون 0).
بالنسبة للمطور الجديد ، قد يستغرق الأمر بعض الوقت لمعرفة كيفية عمل ذلك بالضبط ، وأفضل طريقة لمعرفة ذلك هي اختباره وتعديله.
مثال
مثال على العودية(Recursion)
def tri_recursion(k):
	if(k > 0):
		result = k + tri_recursion(k - 1)
		print(result)
	else:
		result = 0
	return result

print("\n\nRecursion Example Results")
tri_recursion(6)

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

Recursion Example Results
1
3
6
10
15
21 
جربها بنفسك  مِن ملف recursion.py
 
اختبر نفسك مع التمارين
التمرين:
قم بإنشاء دالة باسم my_function.
... ...:
	print("Hello from a function")

الإجابة:
def my_function():
	print("Hello from a function")

نماذج حول الدوال
اضغط هنا لتنزيلها أو تصفحها

دالةْ Lambda في بيثون
دالة لامداْ(lambda) هي دالة صغيرة غير عادية.
يمكن أن تأخذ دالة lambda أي عدد من الوسائط ، ولكن لا يمكن أن تحتوي إلا على تعبير واحد فقط.
 
طريقةْ بناء دالةْ lambda
lambda arguments : expression
يعني في البداية نكتب كلمةْ lambda ثُمَّ الوسائط ثُمَّ علامةْ : ثُمَّ التعبير الذي سيتم تنفيذه.
يتم تنفيذ التعبير و يتم إرجاع النتيجة:
مثال
إضافةْ 10 إلى الوسيطة a، و إرجاع النتيجة:
x = lambda a : a + 10
#لقد أسندنا الدالة lambda إلى المتغير x, فصار x يقوم مقامها.
print(x(5))

ستكون النتيجة:
15 
جربها بنفسك  مِن ملف lambda.py

يمكن أن تأخذ دوال Lambda أي عدد من الوسائط:
مثال
ضرب الوسيطة a مع الوسيطة b وإرجاع النتيجة:
x = lambda a, b : a * b
print(x(5, 6))

ستكون النتيجة:
30 
جربها بنفسك  مِن ملف lambda2.py

مثال
جمع الوسيطة a و b و c وإرجاع النتيجة:
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

ستكون النتيجة:
13 
جربها بنفسك  مِن ملف lambda3.py
  
لماذا تُستخدم وظائف Lambda؟
يتم إظهار قوةْ لامدا بشكل أفضل عند استخدامها كدالة مجهولة داخل دالة أخرى.
لنفترض أن لديك دالة تأخذ وسيطة واحدة ، وسيتم ضرب هذه الوسيطة برقم غير معروف:
def myfunc(n):
	return lambda a : a * n
استخدم الدالة هذه لإنشاء دالة تضاعف دائما الرقم الذي تُدخلُه:
مثال
def myfunc(n):
	return lambda a : a * n

mydoubler = myfunc(2)
# الآن mydoubler يُعبر عن الدالة lambda, و n فيها يساوي 2
print(mydoubler(11))

ستكون النتيجة:
22 
جربها بنفسك  مِن ملف lambda_double.py

أو ، استخدم نفس تعريف الوظيفة لإنشاء وظيفة تضاعف دائما الرقم الذي تُدخلُه ثلاث مرات:
مثال
def myfunc(n):
	return lambda a : a * n

mytripler = myfunc(3)

print(mytripler(11))

ستكون النتيجة:
33 
جربها بنفسك  مِن ملف lambda_triple.py

أو ، استخدم نفس تعريف الوظيفة لجعل كلتا الوظيفتين ، في نفس البرنامج:
مثال
def myfunc(n):
	return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11))
print(mytripler(11))

ستكون النتيجة:
22
33 
جربها بنفسك  مِن ملف lambda_both.py
استخدم وظائف lambda عند الحاجة إلى وظيفة صغيرة و مُساعِدة لفترة قصيرة من الوقت.
 
اختبر نفسك مع التمارين
التمرين:
قم بإنشاء دالة lambda تأخذ معامِل واحد (a) وترجعه.
x = ...

الإجابة :
x= lambda a: a

 نماذج حول الدالة lambda
اضغط هنا لتتصفحها

الصفائف في بايثون(Python Arrays)
ملاحظة: لا يحتوي Python على دعم خاص لـلصفائف (Arrays) ، ولكن يمكن استخدام قوائم Python بدلاً من ذلك.

الصفائف (Arrays)
ملاحظة: توضح لك هذه الصفحة كيفية استخدام القوائم كصفائف ، ومع ذلك ، للعمل مع الصفائفْ في Python ، سيتعين عليك استيراد مكتبة ، مثل مكتبة NumPy.
يتم استخدام صفائف لتخزين قيم متعددة في متغير واحد :
مثال
إنشاء صفيف يحتوي على أسماء السيارات:
cars = ["Ford", "Volvo", "BMW"]

print(cars)

ستكون النتيجة:
['Ford', 'Volvo', 'BMW'] 
جربها بنفسك  مِن ملف array1.py
 
ما هو الصفيف(array)؟
الصفيف هو متغير خاص ، يمكن أن يحتوي على أكثر من قيمة في وقت واحد.
إذا كانت لديك قائمة بالعناصر (قائمة بأسماء السيارات ، على سبيل المثال) ، فقد يبدو تخزين السيارات في متغيرات فردية كما يلي:
car1 = "Ford"
car2 = "Volvo"
car3 = "BMW"
ومع ذلك ، ماذا لو كنت ترغب في إجراء حلقة خلال السيارات والعثور على واحدة محددة ؟ وماذا لو لم يكن لديك 3 سيارات ، ولكن 300؟
الحل هو صفيف(Array)!
يمكن أن يحتوي الصفيف على العديد من القيم تحت اسم واحد ، ويمكنك الوصول إلى القيم بالإشارة إلى رقم الفهرس(index).
 
الوصول إلى عناصر الصفيف
يمكنك الرجوع إلى عنصر صفيف بالإشارة إلى رقم الفهرس(index) الخاص بالعنصر.
مثال
الحصول على قيمة عنصر الصفيف الأول:
cars = ["Ford", "Volvo", "BMW"]
x = cars[0]
print(x)

ستكون النتيجة:
Ford 
جربها بنفسك  مِن ملف array2.py

مثال
تعديل قيمةْ عنصر الصفيف الأول:
cars = ["Ford", "Volvo", "BMW"]
cars[0] = "Toyota"
print(cars)

ستكون النتيجة:
['Toyota', 'Volvo', 'BMW'] 
جربها بنفسك  مِن ملف array3.py
 
طول صفيف
استخدم الدالة len() لإرجاع طول صفيف (عدد العناصر في الصفيف).
مثال
إرجاع عدد العناصر في مجموعة السيارات:
cars = ["Ford", "Volvo", "BMW"]
x = len(cars)
print(x)

ستكون النتيجة:
3 
جربها بنفسك  مِن ملف array4.py
ملاحظة: يكون طول الصفيف دائمًا أكثر من أعلى فهرس في الصفيف بواحد.
 
إجراء حلقة عبر عناصر الصفيف
يمكنك استخدام الحلقة for in لعمل حلقة خلال كافة عناصر الصفيف.
مثال
طباعة كل عنصر في مجموعة cars
cars = ["Ford", "Volvo", "BMW"]
for x in cars:
	print(x)

ستكون النتيجة:
Ford
Volvo
BMW 
جربها بنفسك  مِن ملف array5.py
 
إضافة عناصر إلى الصفيف
يمكنك استخدام الوظيفة append() لإضافة عنصر إلى صفيف.
مثال
إضافة عنصر آخر إلى مجموعة cars
cars = ["Ford", "Volvo", "BMW"]
cars.append("Honda")
print(cars)

ستكون النتيجة:
['Ford', 'Volvo', 'BMW', 'Honda'] 
جربها بنفسك  مِن ملف array6.py
 
إزالةْ عناصر الصفيف
يمكنك استخدام الوظيفة pop() لإزالةْ عنصر من الصفيف.
مثال
حذف العنصر الثاني من مجموعة cars
cars = ["Ford", "Volvo", "BMW"]
cars.pop(1)
print(cars)

ستكون النتيجة:
['Ford', 'BMW'] 
جربها بنفسك  مِن ملف array7.py

يمكنك أيضًا استخدام الوظيفة remove() لإزالةْ عنصر من الصفيف.
مثال
حذف العنصر الذي له قيمة "Volvo":
cars = ["Ford", "Volvo", "BMW"]
cars.remove("Volvo")
print(cars)

ستكون النتيجة:
['Ford', 'BMW'] 
جربها بنفسك  مِن ملف array8.py
ملاحظة:وظيفةْ القائمة remove() تزيل فقط التواجد الأول للقيمة المحددة.
 
وظائف الصفيف
يحتوي Python على مجموعة من الوظائف المضمنة التي يمكنك استخدامها على القوائم / الصفائف.

append()
تضيف عنصرا في نهاية القائمة
clear()
تزيل جميع العناصر من القائمة
copy()
تُرجع نسخة من القائمة
count()
إرجاع عدد العناصر ذات القيمة المحددة
extend()
إضافة عناصر قائمة (أو أي iterable) ، إلى نهاية القائمة الحالية
index()
تُرجع فهرس العنصر الأول ذات القيمة المحددة
insert()
تُضيف عنصرا في موضع محدد
pop()
تُزيل العنصر في الموضع المحدد
remove()
تُزيل العنصر الأول ذو القيمة المحددة
reverse()
تعكس ترتيب العناصر في القائمة
sort()
تُرتبْ العناصر في القائمة
ملاحظة: لا يحتوي Python على دعم مدمج للصفائف ، ولكن يمكن استخدام قوائم Python بدلا من ذلك.
 
نماذج حول الصفائف
اضغط هنا لِتصَفُحِها

فئات بيثون والكائنات(Python Classes and Objects)
فئات / كائنات بايثون(Classes/Objects)
Python هي لغة برمجة تعتمد بشكل كبير على التعامل مع الكائنات.
كل شيء تقريبًا في Python هو كائن ، مع خصائصه و وظائفه.
الفئة(Class) هي مثل منشئ كائن ، أو "مخطط" لإنشاء الكائنات.
 
إنشاء فئة(class)
لإنشاء فئة ، استخدم الكلمة الأساسية class:
مثال
إنشاء فئة تسمى MyClass ، مع خاصية تسمى x:
class MyClass:
	x = 5
print(MyClass)

ستكون النتيجة:
 
جربها بنفسك  مِن ملف class1.py
 
إنشاء كائن(Object)
الآن يمكننا استخدام الفئة المسماة MyClass لإنشاء كائنات:
مثال
إنشاء كائن اسمه p1 ، وطباعة قيمة x:
class MyClass:
	x = 5
p1 = MyClass()
print(p1.x)

ستكون النتيجة:
5 
جربها بنفسك  مِن ملف class2.py
 
وظيفةْ __init __ ()
الأمثلة المذكورة أعلاه هي الفئات والكائنات في أبسط أشكالها ، وليست مفيدة حقا في تطبيقات الحياة الحقيقية.
لفهم معنى الفئات ، يجب أن نفهم وظيفة __init __ () المتضمنة.
تحتوي كافة الفئات على دالة تسمى __init__() ، والتي يتم تنفيذها دائماً عند بدء تشغيل الفئة.
استخدم الدالة __init __ () لإعطاء قيَم لخصائص الكائن ، أو إجراء عمليات أخرى ضرورية للقيام بها عند إنشاء الكائن:
مثال
قم بإنشاء فئة تسمى Person, ، و استخدم الدالة__ init _ _ () لتعيين قيَم للاسم والعمر(name and age):
class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

ستكون النتيجة:
John
36 
جربها بنفسك  مِن ملف class3.py
ملاحظة: يتم استدعاء الدالة__ init _ _ () تلقائيا في كل مرة يتم فيها استخدام الفئة لإنشاء كائن جديد.
 
وظائف الكائن(Object Methods)
يمكن أن تحتوي الكائنات أيضًا على وظائف. الوظائف في الكائنات هي دوال تنتمي إلى الكائن.
دعونا ننشئ وظيفة في فئةْ Person:
مثال
إدراج وظيفة لطباعة تحية ، وتنفيذها على الكائن p1:
class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

	def myfunc(self):
		print("Hello my name is " + self.name)

p1 = Person("John", 36)
p1.myfunc()

ستكون النتيجة:
Hello my name is John 
جربها بنفسك  مِن ملف class4.py
ملاحظة: إنّ المعامِل self هو إشارة إلى الحالة الراهنة للفئة أو الكائن، ويستخدم للوصول إلى المتغيرات  التي تنتمي إلى الفئة.
 
المعامِل self
المعامِل self هو إشارة إلى الحالة الراهنة للفئة أو الكائن، ويستخدم للوصول إلى المتغيرات  التي تنتمي إلى الفئة.
ليس من الضروري تسميتها self، يمكنك تسميتها ما تريد ، ولكن يجب أن تكون المعامِل الأول لأي دالة في الفئة:
مثال
استخدام الكلمات mysillyobject وabc بدلا من self:
class Person:
	def __init__(mysillyobject, name, age):
		mysillyobject.name = name
		mysillyobject.age = age

	def myfunc(abc):
		print("Hello my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc()

ستكون النتيجة:
Hello my name is John 
جربها بنفسك  مِن ملف class5.py
 
تعديل خصائص الكائن
يمكنك تعديل الخصائص في الكائنات مثلما يلي:
مثال
تعديل عُمْر(age) p1 إلى 40:
class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

	def myfunc(self):
		print("Hello my name is " + self.name)

p1 = Person("John", 36)

p1.age = 40

print(p1.age)

ستكون النتيجة:
40 
جربها بنفسك  مِن ملف class6.py
 
حذف خصائص الكائن
يمكنك حذف خصائص الكائنات باستخدام الكلمة الأساسية del:
مثال
حذف خاصية العمر(age) من الكائن p1:
class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

	def myfunc(self):
		print("Hello my name is " + self.name)

p1 = Person("John", 36)

del p1.age

print(p1.age)

ستكون النتيجة:
Traceback (most recent call last):
  File "class7.py", line 13, in 
    print(p1.age)
AttributeError: 'Person' object has no attribute 'age' 
جربها بنفسك  مِن ملف class7.py
 
حذف الكائنات(objects)
يمكنك حذف الكائنات باستخدام الكلمة الأساسية del:
مثال
حذف الكائن p1:
class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

	def myfunc(self):
		print("Hello my name is " + self.name)

p1 = Person("John", 36)

del p1

print(p1)

ستكون النتيجة:
Traceback (most recent call last):
  File "class8.py", line 13, in 
    print(p1)
NameError: 'p1' is not defined 
جربها بنفسك  مِن ملف class8.py
 
عبارةْ التمرير(pass Statement)
لا يمكن أن تكون تعريفات class فارغة، ولكن إذا كان لديك class مع عدم وجود محتوى لسبب ما، ضع فيه عبارة pass لتجنب الحصول على خطأ.
مثال
class Person:
	pass

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

جربها بنفسك  مِن ملف class_pass.py
 
اختبر نفسك مع التمارين
التمرين:
قم بإنشاء فئة باسم MyClass:
... MyClass:
	x = 5

الإجابة :
class MyClass:
	x = 5

نماذج حول فئات بايثون والكائنات
اضغط هنا لتصفحها


الوراثة بالنسبة للفئات والكائنات في بايثون
الوراثة في بايثون(Python Inheritance)
تسمح لنا الوراثة في بايثون بتعريف فئة ترثُ جميع الوظائف والخصائص مِن فئة أخرى.
فئةْ الأصل(Parent class) هي الفئة الموروثة منها ، وتسمى أيضًا الفئة الأساسية(base class).
الفئة الفرعية(Child class) هي الفئة التي ترث من فئة أخرى ، وتسمى أيضًا الفئة المشتقة(derived class).
 
إنشاء فئةْ الأصل(Parent Class)
يمكن أن تكون أي فئة فئة أصل، وبالتالي فإن الطريقة هي نفسها كإنشاء أي فئة أخرى:
مثال
إنشاء فئة تسمى Person، مع الخصائص firstnameو lastname، و الوظيفة printname:
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

#Use the Person class to create an object, and then execute the printname method:

x = Person("John", "Doe")
x.printname()

ستكون النتيجة:
John Doe 
جربها بنفسك  مِن ملف inheritance_parent.py
 
إنشاء فئة تابعة(Child Class)
لإنشاء فئة ترث الخصائص و الوظائف مِن فئة أخرى ، إجعل الفئة الأصل كمعامل عند إنشاء الفئة الفرعية:
مثال
إنشاء فئة باسم Student، والتي سترث الخصائص والوظائف من الفئة Person:
class Student(Person):
	pass
ملاحظة: استخدم الكلمة الرئيسية pass عندما لا ترغب في إضافة أي خصائص أو طرق أخرى إلى الفئة.
الآن فئة Student لها نفس الخصائص والأساليب مثل فئة Person.

مثال
استخدم فئة Student لإنشاء كائن ، ثم قم بتنفيذ الوظيفة printname:
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

class Student(Person):
	pass

x = Student("Mike", "Olsen")
x.printname()

ستكون النتيجة:
Mike Olsen 
جربها بنفسك  مِن ملف inheritance_child.py
 
إضافة وظيفة __init __ ()
لقد أنشأنا حتى الآن فئة فرعية(child class) ترث الخصائص والطرق من أصلها(parent).
نريد إضافة الوظيفة __init__() إلى الفئة الفرعية(child class) بدلاً من الكلمة الأساسية pass.
ملاحظة: يتم استدعاء الدالة __init__() تلقائياً في كل مرة يتم استخدام الفئة لإنشاء كائن جديد.

مثال
إضافة الدالة __init__() إلى فئة Student
class Student(Person):
	def __init__(self, fname, lname):
		#add properties etc.
عند إضافة الدالة__ init _ _ () ، إلى الفئة الفرعية(child class), لن ترث الفئة الفرعية الدالة __init _ _ () الخاصة بفئةْ الأصل أو الوالد(parent class).
ملاحظة:وظيفة الفئة الفرعية __init__()  تتجاوز أو تُلغي وراثة الوظيفة __init__() في الفئة الأصل .
للاحتفاظ بوراثة الدالة __init__() مِن الفئة الأصل، أضف إلى دالة الفئة الفرعية استدعاء  دالة __init__() لفئةْ الأصل:
مثال
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

class Student(Person):
	def __init__(self, fname, lname):
		Person.__init__(self, fname, lname)

x = Student("Mike", "Olsen")
x.printname()

ستكون النتيجة:
Mike Olsen 
جربها بنفسك  مِن ملف inheritance_init.py
الآن لقد أضفنا بنجاح وظيفة __init__ () ، وحافظنا على وراثة الفئة الأصل ، ونحن على استعداد لإضافة وظائف أخرى في وظيفة __init__ ().
 
استخدام الوظيفة super ()
تحتوي لغة Python أيضًا على وظيفة super() تجعل الفئة الفرعية ترث جميع الوظائف والخصائص من الفئة الأصل:
مثال
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

class Student(Person):
	def __init__(self, fname, lname):
		super().__init__(fname, lname)

x = Student("Mike", "Olsen")
x.printname()

ستكون النتيجة:
Mike Olsen 
جربها بنفسك  مِن ملف inheritance_super.py
باستخدام الدالة super() لا نحتاج إلى استخدام اسم العنصر الأصل، فإننا سنرث الأساليب والخصائص تلقائياً من الأصل.
 
إضافة خصائص إلى الفئة الفرعية
مثال
إضافة خاصية تسمى graduationyear إلى فئة Student
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

class Student(Person):
	def __init__(self, fname, lname):
		super().__init__(fname, lname)
		self.graduationyear = 2019

x = Student("Mike", "Olsen")
print(x.graduationyear)

ستكون النتيجة:
2019 
جربها بنفسك  مِن ملف inheritance_add_prop.py

في المثال أدناه ، العام 2019 يجب أن يكون متغيرًا ، ويتم تمريره إلى الفئة Student عند إنشاء عناصر مِن Student. 
للقيام بذلك ، أضف معامِل آخر في دالة __init __ ():
مثال
إضافة معامِل year وتمرير السنة الصحيحة عند إنشاء الكائنات:
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

class Student(Person):
	def __init__(self, fname, lname, year):
		super().__init__(fname, lname)
		self.graduationyear = year

x = Student("Mike", "Olsen", 2019)
print(x.graduationyear)

ستكون النتيجة:
2019 
جربها بنفسك  مِن ملف inheritance_add_prop2.py
 
إضافة وظائف إلى الفئة الفرعية
مثال
إضافة وظيفة تسمى welcome إلى فئة Student
class Person:
	def __init__(self, fname, lname):
		self.firstname = fname
		self.lastname = lname

	def printname(self):
		print(self.firstname, self.lastname)

class Student(Person):
	def __init__(self, fname, lname, year):
		super().__init__(fname, lname)
		self.graduationyear = year

	def welcome(self):
		print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)

x = Student("Mike", "Olsen", 2019)
x.welcome()

ستكون النتيجة:
Welcome Mike Olsen to the class of 2019 
جربها بنفسك  مِن ملف inheritance_add_method.py

إذا قمتَ بإضافة وظيفة في الفئة الفرعية بنفس اسم الدالة في الفئة الأصل(parent class) ، فسيتم تجاوز وراثة الوظيفة الأصل.
 يعني إذا أنشأنا في هذه الحالة, كائناً مِن الفئة الفرعية, فإنّ وظيفة الأصل لا تعود تعمل عليه, بَل فقط الوظيفة الجديدة في الفئة الفرعية.

نماذج حول الوراثة
اضغط هنا لتصفحها

ال Iterators في بايثون
ال iterator هو كائن يحتوي على عدد قابل للعد من القيم.
الiterator هو كائن يمكن التكرار خلاله ، مما يعني أنه يمكنك اجتياز جميع القيم فيه.
من الناحية الفنية ، في Python ، الiterator هو كائن يقوم بتنفيذ بروتوكول iterator ، والذي يتكون من الوظيفتين __iter__ () و__next _ _ ().
 
Iterator مقابل Iterable
القوائم ، المجموعات ، القواميس والمجموعات كلها كائنات قابلة للتكرار خلالها يعني هي iterable. 
و قابلة للتكرار خلالها, يعني أننا يمكن أن نمر على عناصرها بالحلقة for.
و لذلك فإنها حاويات متكررة يمكنك الحصول على iterator منها.
كل هذه الكائنات لها وظيفة iter() التي تستخدم للحصول على iterator منها:
مثال
إرجاع مكرر أو iterator من المصفوفة (tuple) ، وطباعة كل قيمة:
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

ستكون النتيجة:
apple
banana
cherry 
جربها بنفسك  مِن ملف iterator.py

حتى السلاسل النصيِّة  عبارة عن كائنات قابلة للتكرار (iterable)، ويمكنها إرجاع مكرر أو iterator:
مثال
السلاسل النصيِّة هي أيضًا كائنات قابلة للتكرار أي iterable، وتحتوي على سلسلة من الأحرف:
mystr = "banana"
myit = iter(mystr)

print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

ستكون النتيجة:
b
a
n
a
n
a 
جربها بنفسك  مِن ملف iterator2.py
 
حلقات من خلال مكرر(iterator)
يمكننا أيضًا استخدام الحلقة for للتكرار خلال كائن قابل للتكرار يعني iterable:
مثال
عمل حلقة أو التكرار خلال قيم tuple:
mytuple = ("apple", "banana", "cherry")

for x in mytuple:
	print(x)

ستكون النتيجة:
apple
banana
cherry 
جربها بنفسك  مِن ملف iterator_loop.py

مثال
عمل حلقة و التكرار خلال أحرفْ سلسلة نصيَّة:
mystr = "banana"

for x in mystr:
	print(x)

ستكون النتيجة:
b
a
n
a
n
a 
جربها بنفسك  مِن ملف iterator_loop2.py
الحلقة for بالواقع تقوم بإنشاء كائن مكرر أو iterator وتنفيذ الوظيفة next() لكل دورة.
 
 
إنشاء مكرر أو iterator
لإنشاء كائن / فئة ليكون iterator عليك بتنفيذ الوظائف _ _ iter__ () و __next__ () إلى الكائن الخاص بك.
كما تعلمت في فصل Python Classes / Objects ، تحتوي جميع الفئات على وظيفة تسمى _ _ init__ () ، والتي تسمح لك بإجراء بعض التهيئة عند إنشاء الكائن.
تعمل وظيفة _ _ iter__ () بشكل مشابه ، يمكنك القيام بعمليات (تهيئة إلخ.) ، ولكن يجب دائما إرجاع الكائن المكرر نفسه.
تسمح لك وظيفة __ next _ _ () أيضا بإجراء العمليات ، ويجب إرجاع العنصر التالي في التسلسل.

مثال
سنقوم بإنشاء مكرر أو iterator يقوم بإرجاع الأرقام ، بدءا من 1 ، وسيزيد كل تسلسل بمقدار واحد (إرجاع 1 ، 2 ، 3 ، 4 ، 5 إلخ.):
class MyNumbers:
	def __iter__(self):
		self.a = 1
		return self

	def __next__(self):
		x = self.a
		self.a += 1
		return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

ستكون النتيجة:
1
2
3
4
5 
جربها بنفسك  مِن ملف iterator_create.py
 
إيقاف التكرار (Iteration)
سيستمر المثال أعلاه إلى الأبد إذا كان لديك ما يكفي من العبارات next() ، أو إذا تم استخدامه في الحلقة for.
لمنع التكرار من الاستمرار إلى الأبد ، يمكننا استخدام العبارة StopIteration.
في الوظيفة __next__() ، يمكننا إضافة شرط إنْهاء لإثارة خطأ إذا تم التكرار لعدد محدد من المرات:
مثال
إيقاف بعد 20 تكرار:
class MyNumbers:
	def __iter__(self):
		self.a = 1
		return self

	def __next__(self):
		if self.a <= 20:
			x = self.a
			self.a += 1
			return x
		else:
			raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
	print(x)

ستكون النتيجة:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 
جربها بنفسك  مِن ملف iterator_create2.py
 
نماذج حول ال Iterators
اضغط هنا للتنزيل

النطاق في بايثون
المتغير متاح فقط من داخل المنطقة التي تم إنشاؤه فيها. هذا ما يسمى بالنطاق (scope).

النطاق المحلي(Local Scope)
ينتمي المتغير الذي تم إنشاؤه داخل دالة إلى النطاق المحلي لتلك الوظيفة ، ولا يمكن استخدامه إلا داخل هذه الوظيفة.
مثال
المتغير الذي تم إنشاؤه داخل دالة يبقى متوفرا و متاحا داخل تلك الوظيفة:
def myfunc():
	x = 300
	print(x)

myfunc()

ستكون النتيجة:
300 
جربها بنفسك  مِن ملف scope1.py

وظيفة داخل الوظيفة
كما هو موضح في المثال أعلاه ، المتغير xغير متاح خارج الوظيفة ، ولكنه متاح لأي دالة يمكن أن تكون موجودة داخل الوظيفة:
مثال
يمكن الوصول إلى المتغير المحلي من خلال دالة داخل الوظيفة:
def myfunc():
	x = 300
	def myinnerfunc():
		print(x)
	myinnerfunc()

myfunc()

ستكون النتيجة:
300 
جربها بنفسك  مِن ملف scope2.py 
 
النطاق العام(Global Scope)
المتغير الذي يتم إنشاؤه في الجزء الرئيسي من كود Python هو متغير عمومي وينتمي إلى النطاق العام.
المتغيرات العامة تبقى متاحة من داخل أي نطاق ، عام أو محلي.
مثال
المتغير الذي يتم إنشاؤه خارج الدالة يكون عامًا ويمكن لأي أحد استخدامه, يعني مِن أي مكان:
x = 300

def myfunc():
	print(x)

myfunc()

print(x)

ستكون النتيجة:
300
300 
جربها بنفسك  مِن ملف scope3.py

تسمية المتغيرات
إذا كنتَ تعمل بنفس اسم المتغير داخل وخارج الدالة ، فسيتعامل معهما Python كمتغيرين منفصلين ، أحدهما متاح في النطاق العام (خارج الوظيفة) والآخر متاح في النطاق المحلي (داخل الوظيفة):
مثال
ستقوم الوظيفة بطباعة المتغير x المحلي ، ثم يقوم السكربت الرئيسي بطباعة المتغير x العام :
x = 300

def myfunc():
	x = 200
	print(x)

myfunc()

print(x)

ستكون النتيجة:
200
300 
جربها بنفسك  مِن ملف scope4.py
 
الكلمة الرئيسية global
إذا كنت بحاجة إلى إنشاء متغير عام ، ولكنك موجود أو عالق في النطاق المحلي ، يمكنك استخدام الكلمة الرئيسية global.
الكلمة الرئيسية global تجعل المتغير متغيرا عاما.
مثال
إذا كنت تستخدم الكلمة الأساسية global ، فإن المتغير ينتمي إلى النطاق العام:
def myfunc():
	global x
	x = 300

myfunc()

print(x)

ستكون النتيجة:
300 
جربها بنفسك  مِن ملف scope5.py

أيضًا ، استخدم الكلمة الأساسية global إذا كنت تريد إجراء تغيير على متغير عام و أنت داخل دالة.
مثال
لتغيير قيمة متغير عام مِن داخل دالة ، أشر إلى المتغير باستخدام الكلمة الأساسية global:
x = 300

def myfunc():
	global x
	x = 200

myfunc()

print(x)

ستكون النتيجة:
200 
جربها بنفسك  مِن ملف scope6.py
 
نماذج حول النطاق
اضغط هنا للتنزيل

الوحدات في بايثون(Python Modules)
يمكن أن نسميها وحدة أو مكتبة, فكلاهما يؤديان نفس المعنى

ما هي الوحدة(module)؟
ضع في اعتبارك أن الوحدة النمطية هي نفسها مكتبة تحتوي على كود بلغةْ بايثون.
ملف يحتوي على مجموعة من الوظائف التي تريد تضمينها في التطبيق الخاص بك.
 
إنشاء وحدة نمطية(module)
لإنشاء وحدة نمطية فقط قم بحفظ التعليمات البرمجية أو الكود الذي تريده في ملف مع إمتداد .py:
مثال
احفظ هذا الكود في ملف اسمه mymodule.py
def greeting(name):
	print("Hello, " + name)
استخدام الوحدة النمطية
الآن يمكننا استخدام المكتبة أو الوحدة التي أنشأناها للتو ، باستخدام عبارةْ الاستيراد import:
مثال
استيراد الوحدة النمطية المسماة mymodule، و استدعاء دالة greeting الموجودة فيها:
import mymodule

mymodule.greeting("Jonathan")

ستكون النتيجة:
Hello, Jonathan 
تشغيل المثال » مِن مُجَلَّد module1
ملاحظة: عند استخدام وظيفة من وحدة نمطية، استخدم الأسلوب: module_name.function_name .
 
المتغيرات في الوحدة(module)
يمكن أن تحتوي الوحدة النمطية على وظائف ، كما سَبَقَ و رأينا بالفعل .
ولكن أيضًا يمكن أن تحتوي على متغيرات من جميع الأنواع (مصفوفات ، قواميس ، كائنات ، إلخ):
مثال
احفظ هذا الكود في الملف mymodule.py
person1 = {
	"name": "John",
	"age": 36,
	"country": "Norway"
}
مثال
استيراد الوحدة المسماة mymodule ، والوصول إلى قاموس person1:
import mymodule

a = mymodule.person1["age"]
print(a)

ستكون النتيجة:
36 
تشغيل المثال » مِن مُجَلَّد module2
  
تسمية الوحدة النمطية
يمكنك تسمية ملف الوحدة ما تريد ، ولكن يجب أن يكون إمتداد الملف هو .py

إعادة تسمية وحدة نمطية
يمكنك إنشاء اسم مستعار عند استيراد الوحدة النمطية باستخدام الكلمة الرئيسية as:
مثال
إنشاء اسم مستعار للوحدة mymodule يُسمى mx:
import mymodule as mx

a = mx.person1["age"]
print(a)

ستكون النتيجة:
36 
تشغيل المثال » مِن مُجَلَّد module3
 
الوحدات المُتضمَنة أو المدمجة(Built-in Modules)
هناك العديد من الوحدات المدمجة في بيثون ، والتي يمكنك استيرادها وقتما تشاء.
مثال
استيراد واستخدام وحدة platform
import platform

x = platform.system()
print(x)

النتيجة:
Windows 
جربها بنفسك  مِن ملف module4.py
 
استخدام الوظيفة dir ()
هناك وظيفة مدمجة لسَرد جميع أسماء الوظائف (أو أسماء المتغيرات) في أي وحدة نمطية. ألا و هي وظيفة dir ():
مثال
سرد كافة الأسماء المعرفة التي تنتمي إلى الوحدة النمطية platform:
import platform

x = dir(platform)
print(x)

 النتيجة:
['DEV_NULL', '_UNIXCONFDIR', '_WIN32_CLIENT_RELEASES', '_WIN32_SERVER_RELEASES', '__builtins__', '__cached__', '__copyri
ght__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '__version__', '_comparable_version'
, '_component_re', '_default_architecture', '_dist_try_harder', '_follow_symlinks', '_ironpython26_sys_version_parser',
'_ironpython_sys_version_parser', '_java_getprop', '_libc_search', '_linux_distribution', '_lsb_release_version', '_mac_
ver_xml', '_node', '_norm_version', '_parse_release_file', '_platform', '_platform_cache', '_pypy_sys_version_parser', '
_release_filename', '_release_version', '_supported_dists', '_sys_version', '_sys_version_cache', '_sys_version_parser',
 '_syscmd_file', '_syscmd_uname', '_syscmd_ver', '_uname_cache', '_ver_output', '_ver_stages', 'architecture', 'collecti
ons', 'dist', 'java_ver', 'libc_ver', 'linux_distribution', 'mac_ver', 'machine', 'node', 'os', 'platform', 'popen', 'pr
ocessor', 'python_branch', 'python_build', 'python_compiler', 'python_implementation', 'python_revision', 'python_versio
n', 'python_version_tuple', 're', 'release', 'subprocess', 'sys', 'system', 'system_alias', 'uname', 'uname_result', 've
rsion', 'warnings', 'win32_ver']
جربها بنفسك  مِن ملف module5.py
ملاحظة: يمكن استخدام الوظيفة dir() على جميع الوحدات ، وكذلك تلك التي تقوم بإنشائها بنفسك.
 
الاستيراد من الوحدة النمطية
يمكنك اختيار استيراد أجزاء فقط من وحدة نمطية، باستخدام الكلمة from.
مثال
الوحدة المسماة mymodule لها وظيفة واحدة وقاموس واحد:
def greeting(name):
	print("Hello, " + name)

person1 = {
	"name": "John",
	"age": 36,
	"country": "Norway"
}
مثال
استيراد القاموس person1 فقط من الوحدة النمطية:
from mymodule import person1

print (person1["age"])

ستكون النتيجة:
36 
تشغيل المثال » مِن مُجَلَّد module6
ملاحظة: عند الاستيراد باستخدام الكلمة الأساسية from لا تستخدم اسم الوحدة النمطية عند الإشارة إلى عناصر في الوحدة النمطية. 
يعني: person1["age"] ، وليس mymodule.person1["age"]
  
اختبر نفسك مع التمارين
التمرين:
ما هو الأسلوب الصحيح لاستيراد وحدة نمطية تسمى "mymodule"؟
... mymodule

الإجابة :
import mymodule

نماذج حول المكتبات أو الوحدات
اضغط هنا للتنزيل

التاريخ والوقت في بيثون(Datetime)
التاريخ في بايثون(Date)
التاريخ في Python ليس نوع بيانات خاص به ، ولكن يمكننا استيراد وحدة نمطية تسمى datetime للعمل مع التواريخ وكائنات التاريخ.
مثال
استيراد وحدةْ datetime المتعلقة بالتاريخ والوقت, وعرض التاريخ الحالي:
import datetime

x = datetime.datetime.now()
print(x)

النتيجة:
2020-11-27 11:50:42.599532
جربها بنفسك  مِن ملف datetime1.py
 
إخراج التاريخ(Date Output)
عندما نُنفذ الكود من المثال أعلاه ، ستكون النتيجة:
2020-11-27 11:50:42.599532
يحتوي التاريخ على السنة والشهر واليوم والساعة والدقيقة والثانية والميكرو ثانية.
تحتوي datetimeالوحدة النمطية على العديد من الطرق لإرجاع معلومات حول كائن التاريخ.
فيما يلي بعض الأمثلة ، سوف تتعلم المزيد عنها لاحقًا في هذا الفصل:
مثال
إرجاع السنة و اسم يوم الأسبوع:
import datetime

x = datetime.datetime.now()

print(x.year)
print(x.strftime("%A"))

النتيجة:
2020
Friday
جربها بنفسك  مِن ملف datetime2.py
 
إنشاء كائنات التاريخ
لإنشاء تاريخ ، يمكننا استخدام فئة datetime() مِن الوحدة النمطية datetime.
و تتطلب فئة datetime() ثلاث مُعامِلات أو وسائط لإنشاء تاريخ: السنة والشهر واليوم.
مثال
إنشاء كائن تاريخ(date object):
import datetime

x = datetime.datetime(2020, 5, 17)

print(x)

النتيجة:
2020-05-17 00:00:00 
جربها بنفسك  مِن ملف datetime3.py
تأخذ فئة datetime() أيضا مُعامِلات للوقت والمنطقة الزمنية (ساعة ، دقيقة ، ثانية ، ميكروثانية ، tzone) ، ولكنها كلها مُعامِلات اختيارية ، ولها قيمة افتراضية 0 ، (None  للمنطقة الزمنية  timezone).
  
الوظيفة strftime ()
يحتوي كائن datetime على وظيثة لتنسيق كائنات التاريخ في سلاسل نصِّيَة قابلة للقراءة.
تسمى الوظيفة strftime () ، وتأخذ وسيطة واحدة ، format(تنسيق) ، لتحديد تنسيق السلسلة التي سيتم إرجاعها:
مثال
عرض اسم الشهر:
import datetime

x = datetime.datetime(2018, 6, 1)

print(x.strftime("%B"))

ستكون النتيجة:
June 
جربها بنفسك  مِن ملف datetime_strftime.py

فيما يلي مرجع لجميع رموز التنسيق القانوني:
%a
أيام الأسبوع ، الإسم مختصَر
نموذج على ذلك: Wed
مثال
import datetime

x = datetime.datetime.now()

print(x.strftime("%a"))

النتيجة:
Sat 
جربها بنفسك » مِن ملف datetime_strftime_a.py

%A
أيام الأسبوع ، الإسم الكامل
نموذج على ذلك: Wednesday
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%A"))

النتيجة:
Saturday 
جربها بنفسك » مِن ملف datetime_strftime_a2.py

%w
أيام الأسبوع كرقم 0-6 ، 0 هو الأحد
نموذج على ذلك: 3
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%w"))

النتيجة:
6 
جربها بنفسك » مِن ملف datetime_strftime_w.py

%d
أيام الشهر كرقم 01-31
نموذج على ذلك: 31
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%d"))

النتيجة:
28 
جربها بنفسك » مِن ملف datetime_strftime_d.py

%b
اسم الشهر الإسم مختصَر
نموذج على ذلك: Dec
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%b"))

النتيجة:
Nov 
جربها بنفسك » مِن ملف datetime_strftime_b.py

%B
اسم الشهر, الإسم الكامل
نموذج على ذلك: December
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%B"))
النتيجة:
November 
جربها بنفسك » مِن ملف datetime_strftime_b2.py

%m
الشهر كرقم 01-12
نموذج على ذلك: 12
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%m"))

النتيجة:
11 
جربها بنفسك » مِن ملف datetime_strftime_m.py

%y
السنة ، نسخة قصيرة ، دون القرن
نموذج على ذلك: 18
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%y"))

النتيجة:
20 
جربها بنفسك » مِن ملف datetime_strftime_y.py
ملحوظة: 20 في المثال السابق تعني سنة 2020

%Y
العام ، الرقم الكامل
نموذج على ذلك: 2018
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%Y"))

النتيجة:
2020 
جربها بنفسك » مِن ملف datetime_strftime_y2.py

%H
الساعة 00-23
نموذج على ذلك: 17
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%H"))

النتيجة:
04 
جربها بنفسك » مِن ملف datetime_strftime_h2.py

%I
الساعة 00-12
نموذج على ذلك: 05
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%I"))

النتيجة:
04 
جربها بنفسك » مِن ملف datetime_strftime_i2.py

%p
AM/PM(صباحا / مساء)
نموذج على ذلك: PM
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%p"))

النتيجة:
AM 
جربها بنفسك » مِن ملف datetime_strftime_p.py

%M
الدقائق 00-59
نموذج على ذلك: 41
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%M"))

النتيجة:
58 
جربها بنفسك » مِن ملف datetime_strftime_m2.py

%S
الثواني 00-59
نموذج على ذلك: 08
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%S"))

النتيجة:
47 
جربها بنفسك » مِن ملف datetime_strftime_s2.py

%f
ميكروثانية 000000-999999
نموذج على ذلك: 548513
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%f"))

النتيجة:
004630 
جربها بنفسك » مِن ملف datetime_strftime_f.py

%z
UTC offset
نموذج على ذلك: +0100

%Z
Timezone(المنطقة الزمنية)
نموذج على ذلك: CST
 
%j
رقم اليوم في السنة 001-366
نموذج على ذلك: 365
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%j"))

النتيجة:
333 
جربها بنفسك » مِن ملف datetime_strftime_j.py

%U
رقم الأسبوع مِن السنة , الأحد أول يوم مِن الأسبوع, 00-53
نموذج على ذلك: 52
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%U"))

النتيجة:
47
جربها بنفسك » مِن ملف datetime_strftime_u2.py

%W
رقم الأسبوع مِن السنة, الإثنين أول أيام الأسبوع, 00-53
نموذج على ذلك: 52
مثال:
import datetime

x = datetime.datetime(2018, 5, 31)

print(x.strftime("%W"))

النتيجة:
22
جربها بنفسك » مِن ملف datetime_strftime_w2.py

%c
النسخة المحلية من التاريخ والوقت
نموذج على ذلك: Mon Dec 31 17:41:00 2018
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%c"))

النتيجة:
Sat Nov 28 06:03:41 2020 
جربها بنفسك » مِن ملف datetime_strftime_c.py

%x
الأسلوب المحلي لعرض التاريخ
نموذج على ذلك: 12/31/18
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%x"))

النتيجة:
11/28/20 
جربها بنفسك » مِن ملف datetime_strftime_x.py

%X
الطريقة المحليَّة لعرض الوقت
نموذج على ذلك: 17:41:00
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%X"))

النتيجة:
07:06:54 
جربها بنفسك » مِن ملف datetime_strftime_x2.py

%%
علامةْ % 
نموذج على ذلك: %
مثال:
import datetime

x = datetime.datetime.now()

print(x.strftime("%%"))

النتيجة:
% 
جربها بنفسك » مِن ملف datetime_strftime_percent.py
 
نماذج حول التاريخ والوقتاضغط هنا للتنزيل

الرياضيات في بايثون(Python Math)
يحتوي Python على مجموعة من وظائف الرياضيات المدمجة ، بما في ذلك وحدة الرياضيات الشاملة ، التي تسمح لك بأداء المهام الرياضية على الأرقام.
 
وظائف الرياضيات المدمجة (Built-in Math Functions)
يمكن استخدام وظائف min() و max () للعثور على أدنى أو أعلى قيمة في السلسلة أو الكائن القابل للتكرار(iterable):
المثال
x = min(5, 10, 25)
y = max(5, 10, 25)

print(x)
print(y)

ستكون النتيجة:
5
25 
جربها بنفسك  مِن ملف math_min_max.py


المثال
x = abs(-7.25)

print(x)

ستكون النتيجة:
7.25 
جربها بنفسك  مِن ملف math_abs.py

الدالة pow(x, y) ترجع قيمة x إلى قوة y, يعني x أُس y.
المثال
إرجاع قيمة 4 إلى قوة 3 (تماما مثل 4 * 4 * 4):
x = pow(4, 3)

print(x)

ستكون النتيجة:
64 
جربها بنفسك  مِن ملف math_pow.py
 
وحدةْ أو مكتبةْ الرياضيات(Math Module)
يحتوي Python أيضًا على وحدة نمطية مدمجة تسمى math، والتي تُوسع قائمة الوظائف الرياضية.
لاستخدامها ، يجب عليك استيراد الوحدة math:
import math
عندما تقوم باستيراد الوحدة math ، يمكنك البدء في استخدام وظائف وثوابت الوحدة.
الوظيفة math.sqrt() على سبيل المثال، تقوم بإرجاع الجذر التربيعي للرقم:
مثال
importmath

x = math.sqrt(64)

print(x)

ستكون النتيجة:
8.0 
جربها بنفسك  مِن ملف math_sqrt.py

تقوم وظيفة math.ceil() بتقريب الرقم لأعلى إلى أقرب عدد صحيح، 
وتقوم وظيفة math.floor() بتقريب الرقم لِأسفل إلى أقرب عدد صحيح له، وإرجاع النتيجة:
مثال
importmath

x = math.ceil(1.4)
y = math.floor(1.4)

print(x) # returns 2
print(y) # returns 1

ستكون النتيجة:
2
1 
جربها بنفسك  مِن ملف math_ceil_floor.py

الثابت math.pi يُرجع قيمة PI (3.14...):
مثال
importmath

x = math.pi

print(x)

ستكون النتيجة:
3.141592653589793 
جربها بنفسك  مِن ملف math_pi.py
 
المرجع الشامل لِوحدة الرياضيات(Complete Math Module Reference)
في مرجع وحدة الرياضيات لدينا سوف تجد مرجعا كاملا لجميع الوظائف والثوابت التي تنتمي إلى وحدة الرياضيات.
انتقل إليه من هنا

نماذج حول الرياضيات
اضغط هنا للتنزيل
 
استخدام الجيسون JSON في بايثون
JSON هو أسلوب يستخدم لتخزين البيانات وتبادلها.
JSON هو نص, يُكتب باستخدام تدوين كائن جافا سكريبت(JavaScript object notation).
 
JSON في بايثون
يحتوي Python على حزمة مدمجة(built-in package ) تسمى json، والتي يمكن استخدامها للعمل مع بيانات JSON.
مثال
استيراد وحدة json:
import json
 
تحليل JSON - التحويل من JSON إلى Python
إذا كانت لديك سلسلة JSON ، فيمكنك تحليلها و تحويلها إلى بايثون باستخدام الوظيفة json.loads().
والنتيجة ستكون قاموس مِن قواميس بيثون.
مثال
التحويل من JSON إلى Python:
import json

# some JSON:
x =  '{ "name":"John", "age":30, "city":"New York"}'

# parse x:
y = json.loads(x)

# the result is a Python dictionary:
print(y["age"])

ستكون النتيجة:
30 
جربها بنفسك  مِن ملف json.py
 
التحويل من Python إلى JSON
إذا كان لديك كائن Python ، فيمكنك تحويله إلى سلسلة JSON باستخدام الوظيفة json.dumps().
مثال
التحويل من Python إلى JSON:
import json

# a Python object (dict):
x = {
  "name": "John",
  "age": 30,
  "city": "New York"
}

# convert into JSON:
y = json.dumps(x)

# the result is a JSON string:
print(y)

ستكون النتيجة:
{"name": "John", "age": 30, "city": "New York"} 
جربها بنفسك  مِن ملف json_from_python.py
 ملحوظة: النتيجة هي سلسلة نصِّيَّة, لكن علامات التنصيص لا تظهر عند طباعتها.
 
يمكنك تحويل كائنات Python من الأنواع التالية ، إلى سلاسل JSON:
• قاموس dict
• قائمة list
• مصفوفة tuple
• سلسلة نصيَّة str
• الرقم الصحيح  int
• الرقم العائم float
• القيمة المنطقية True
• القيمة المنطقية False
• القيمة None

مثال
تحويل كائنات Python إلى سلاسل JSON ، وطباعة القيم:
import json

print(json.dumps({"name": "John", "age": 30}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None))

ستكون النتيجة:
{"name": "John", "age": 30}
["apple", "bananas"]
["apple", "bananas"]
"hello"
42
31.76
true
false
null 
جربها بنفسك  مِن ملف json_from_python_all.py
 
عندما تقوم بالتحويل من Python إلى JSON ، يتم تحويل كائنات Python إلى مكافئ JSON لها في جافا سكريبت(JavaScript):
dict
المكافئ لها
Object
list
المكافئ لها
Array
tuple
المكافئ لها
Array
str
المكافئ لها
String
int
المكافئ لها
Number
float
المكافئ لها
Number
True
المكافئ لها
true
False
المكافئ لها
false
None
المكافئ لها
null
 
مثال
تحويل كائن Python يحتوي على كافة أنواع البيانات القانونية:
import json

x = {
  "name": "John",
  "age": 30,
  "married": True,
  "divorced": False,
  "children": ("Ann","Billy"),
  "pets": None,
  "cars": [
    {"model": "BMW 230", "mpg": 27.5},
    {"model": "Ford Edge", "mpg": 24.1}
  ]
}

print(json.dumps(x))

ستكون النتيجة:
{"name": "John", "age": 30, "married": true, "divorced": false, "children": ["Ann", "Billy"], "pets": null, "cars": [{"model": "BMW 230", "mpg": 27.5}, {"model": "Ford Edge", "mpg": 24.1}]}
جربها بنفسك  مِن ملف json_from_python_all_in_one.py
 
تنسيق النتيجة
المثال أعلاه يَطْبع سلسلة JSON ، لكن ليس من السهل قراءتها ، بدون مسافات بادئة أو إزاحة وفواصل أَسْطُر.
تحتوي الوظيفة json.dumps() على مُعامِلات لتسهيل قراءة النتيجة:
مثال
استخدم المعامِل indent لتحديد عدد الإزاحات أو المسافات البادئة:
import json

x = {
	"name": "John",
	"age": 30,
	"married": True,
	"divorced": False,
	"children": ("Ann","Billy"),
	"pets": None,
	"cars": [
		{"model": "BMW 230", "mpg": 27.5},
		{"model": "Ford Edge", "mpg": 24.1}
	]
}

# use four indents to make it easier to read the result:
print(json.dumps(x, indent=4))

ستكون النتيجة:
{
		"name": "John",
		"age": 30,
		"married": true,
		"divorced": false,
		"children": [
				"Ann",
				"Billy"
		],
		"pets": null,
		"cars": [
				{
						"model": "BMW 230",
						"mpg": 27.5
				},
				{
						"model": "Ford Edge",
						"mpg": 24.1
				}
		]
} 

جربها بنفسك  مِن ملف json_from_python_indent.py

يمكنك أيضًا تحديد الفواصل ، القيمة الافتراضية هي ("،"، ":") ، مما يعني استخدام فاصلة ومسافة لفصل كل كائن ، ونقطتين ومسافة لفصل المفاتيح عن القيم:
مثال
استخدام المعامِل separators لتغيير الفاصل الافتراضي:
import json

x = {
	"name": "John",
	"age": 30,
	"married": True,
	"divorced": False,
	"children": ("Ann","Billy"),
	"pets": None,
	"cars": [
		{"model": "BMW 230", "mpg": 27.5},
		{"model": "Ford Edge", "mpg": 24.1}
	]
}

# use . and a space to separate objects, and a space, a = and a space to separate keys from their values:
print(json.dumps(x, indent=4, separators=(". ", " = ")))

ستكون النتيجة:
{
		"name" = "John".
		"age" = 30.
		"married" = true.
		"divorced" = false.
		"children" = [
				"Ann".
				"Billy"
		].
		"pets" = null.
		"cars" = [
				{
						"model" = "BMW 230".
						"mpg" = 27.5
				}.
				{
						"model" = "Ford Edge".
						"mpg" = 24.1
				}
		]
} 
جربها بنفسك  مِن ملف json_from_python_separators.py
 
تنظيم أو ترتيب  النتيجة
تحتوي الوظيفة json.dumps() على مُعامِلات لترتيب المفاتيح في النتيجة:
مثال
استخدم المُعامِل sort_keys لتحديد ما إذا كان يجب ترتيب أو فرز(sort) النتيجة أَم لا:
import json

x = {
	"name": "John",
	"age": 30,
	"married": True,
	"divorced": False,
	"children": ("Ann","Billy"),
	"pets": None,
	"cars": [
		{"model": "BMW 230", "mpg": 27.5},
		{"model": "Ford Edge", "mpg": 24.1}
	]
}

# sort the result alphabetically by keys:
print(json.dumps(x, indent=4, sort_keys=True))

ستكون النتيجة:
{
		"age": 30,
		"cars": [
				{
						"model": "BMW 230",
						"mpg": 27.5
				},
				{
						"model": "Ford Edge",
						"mpg": 24.1
				}
		],
		"children": [
				"Ann",
				"Billy"
		],
		"divorced": false,
		"married": true,
		"name": "John",
		"pets": null
} 
جربها بنفسك  مِن ملف json_from_python_sort_keys.py
 
نماذج حول json
اضغط هنا للتنزيل

التعبيرات النمطية لغة RegEx في Python
RegEx ، و الذي هو اختصار لِ Regular Expression (التعبير المنظم) ، هو سلسلة من الأحرف التي تُشكل نمط بحث.
يمكن استخدام RegEx للتحقق مما إذا كانت السلسلة النصِّيَّة تحتوي على نمط البحث المحدد.
 
وحدةْ أو مكتبةْ RegEx(RegEx Module)
يحتوي Python على حُزمة مدمجة تسمى re ، والتي يمكن استخدامها للعمل مع regular expressions.
استيراد الوحدة re:
import re
 
RegEx في Python
عند استيراد وحدة re ، يمكنك البدء في استخدام regular expressions:
مثال
ابحث في السلسلة لمعرفة ما إذا كانت تبدأ بـ "The" وتنتهي بـ "Spain":
import re

#Check if the string starts with "The" and ends with "Spain":

txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt)

if x:
	print("YES! We have a match!")
else:
	print("No match")

ستكون النتيجة:
YES! We have a match! 
جربها بنفسك  مِن ملف regex.py
 
وظائف RegEx
الوحدة re تُقدم لنا مجموعة من الوظائف التي تسمح لنا للبحث في سلسلة نصِّيَّة عن الجزء المطابق لِ regex:

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

[]
مجموعة مِن الأحرف
"[a-m]"
مثال
import re

txt = "The rain in Spain"

#Find all lower case characters alphabetically between "a" and "m":

x = re.findall("[a-m]", txt)
print(x)

ستكون النتيجة:
['h', 'e', 'a', 'i', 'i', 'a', 'i'] 
Try it » مِن ملف regex_meta1.py

\
تشير إلى تسلسل خاص (يمكن استخدامها أيضا لتمرير الأحرف الخاصة)
"\d"
مثال
import re

txt = "That will be 59 dollars"

#Find all digit characters:

x = re.findall("\d", txt)
print(x)

ستكون النتيجة:
['5', '9'] 
جربها بنفسك » مِن ملف regex_meta2.py

.
أي حرف (باستثناء حرف السطر الجديد \n)
"he..o"
مثال
import re

txt = "hello world"

#Search for a sequence that starts with "he", followed by two (any) characters, and an "o":

x = re.findall("he..o", txt)
print(x)

ستكون النتيجة:
['hello'] 
جربها بنفسك » مِن ملف regex_meta3.py

^
يبدأ بِ, يشير إلى البداية
"^hello"
مثال
import re

txt = "hello world"

#Check if the string starts with 'hello':

x = re.findall("^hello", txt)
if x:
	print("Yes, the string starts with 'hello'")
else:
	print("No match")

ستكون النتيجة:
Yes, the string starts with 'hello'
جربها بنفسك » مِن ملف regex_meta4.py

$
ينتهي بِ, يشير إلى النهاية
"world$"
مثال
import re

txt = "hello world"

#Check if the string ends with 'world':

x = re.findall("world$", txt)
if x:
	print("Yes, the string ends with 'world'")
else:
	print("No match")

ستكون النتيجة:
Yes, the string ends with 'world'
جربها بنفسك » مِن ملف regex_meta5.py

*
صفر مِن الحرف السابق أو أكثر
"aix*"
مثال
import re

txt = "The rain in Spain falls mainly in the plain!"

#Check if the string contains "ai" followed by 0 or more "x" characters:

x = re.findall("aix*", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['ai', 'ai', 'ai', 'ai']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_meta6.py

+
واحد أو أكثر مِن الحرف السابق
"aix+"
مثال
import re

txt = "The rain in Spain falls mainly in the plain!"

#Check if the string contains "ai" followed by 1 or more "x" characters:

x = re.findall("aix+", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك » مِن ملف regex_meta7.py

{}
بالضبط العدد المحدد من التكرارات
"al{2}"
مثال
import re

txt = "The rain in Spain falls mainly in the plain!"

#Check if the string contains "a" followed by exactly two "l" characters:

x = re.findall("al{2}", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['all']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_meta8.py

|
إما أو
"falls|stays"
مثال
import re

txt = "The rain in Spain falls mainly in the plain!"

#Check if the string contains either "falls" or "stays":

x = re.findall("falls|stays", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['falls']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_meta9.py

()
التقاط مجموعة, () تُحدد المجموعة

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

\A
إرجاع تطابق إذا كانت الأحرف المحددة في بداية السلسلة
"\AThe"
مثال
import re

txt = "The rain in Spain"

#Check if the string starts with "The":

x = re.findall("\AThe", txt)

print(x)

if x:
	print("Yes, there is a match!")
else:
	print("No match")

ستكون النتيجة:
['The']
Yes, there is a match! 
جربها بنفسك » مِن ملف regex_seq1.py

\b
إرجاع تطابق حيث الأحرف المحددة هي في بداية أو في نهاية كلمة
(the "r" in the beginning is making sure that the string is being treated as a "raw string")
r"\bain"
r"ain\b"
مثال
import re

txt = "The rain in Spain"

#Check if "ain" is present at the beginning of a WORD:

x = re.findall(r"\bain", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك » مِن ملف regex_seq2.py

مثال
import re

txt = "The rain in Spain"

#Check if "ain" is present at the end of a WORD:

x = re.findall(r"ain\b", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['ain', 'ain']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_seq2-.py

\B
إرجاع تطابُق حيث الأحرف المحددة موجودة ، ولكن ليس في بدايةْ (أو في نهايةْ) الكلمة
(the "r" in the beginning is making sure that the string is being treated as a "raw string")
r"\Bain"
r"ain\B"
مثال
import re

txt = "The rain in Spain"

#Check if "ain" is present, but NOT at the beginning of a word:

x = re.findall(r"\Bain", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['ain', 'ain']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_seq3.py

مثال
import re

txt = "The rain in Spain"

#Check if "ain" is present, but NOT at the end of a word:

x = re.findall(r"ain\B", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك » مِن ملف regex_seq3-2.py

\d
إرجاع تطابُق حيث تحتوي السلسلة على أرقام (أرقام من 0-9)
"\d"
مثال
import re

txt = "The rain in Spain"

#Check if the string contains any digits (numbers from 0-9):

x = re.findall("\d", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك » مِن ملف regex_seq4.py

\D
إرجاع تطابق حيث لا تحتوي السلسلة على أرقام
"\D"
مثال
import re

txt = "The rain in Spain"

#Return a match at every no-digit character:

x = re.findall("\D", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['T', 'h', 'e', ' ', 'r', 'a', 'i', 'n', ' ', 'i', 'n', ' ', 'S', 'p', 'a', 'i', 'n']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_seq5.py

\s
إرجاع تطابُق حيث تحتوي السلسلة على حرف مساحة بيضاء
"\s"
مثال
import re

txt = "The rain in Spain"

#Return a match at every white-space character:

x = re.findall("\s", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[' ', ' ', ' ']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_seq6.py

\S
إرجاع تطابُق حيث لا تحتوي السلسلة على حرف مساحة بيضاء
"\S"
مثال
import re

txt = "The rain in Spain"

#Return a match at every NON white-space character:

x = re.findall("\S", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['T', 'h', 'e', 'r', 'a', 'i', 'n', 'i', 'n', 'S', 'p', 'a', 'i', 'n']
Yes, there is at least one match!
جربها بنفسك » مِن ملف regex_seq7.py

\w
إرجاع تطابق حيث تحتوي السلسلة على أي أحرف مِن الكلمة (أحرف من a إلى z ، أرقام من 0-9 ، وحرف _ underscore)
"\w"
مثال
import re

txt = "The rain in Spain"

#Return a match at every word character (characters from a to Z, digits from 0-9, and the underscore _ character):

x = re.findall("\w", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['T', 'h', 'e', 'r', 'a', 'i', 'n', 'i', 'n', 'S', 'p', 'a', 'i', 'n']
Yes, there is at least one match!
جربها بنفسك » مِن ملف regex_seq8.py

\W
إرجاع تطابُق حيث لا تحتوي السلسلة على أي أحرف مِن الكلمة
"\W"
مثال
import re

txt = "The rain in Spain"

#Return a match at every NON word character (characters NOT between a and Z. Like "!", "?" white-space etc.):

x = re.findall("\W", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[' ', ' ', ' ']
Yes, there is at least one match!
جربها بنفسك » مِن ملف regex_seq9.py

\Z
إرجاع تطابق إذا كانت الأحرف المحددة في نهاية السلسلة
"Spain\Z"
مثال
import re

txt = "The rain in Spain"

#Check if the string ends with "Spain":

x = re.findall("Spain\Z", txt)

print(x)

if x:
	print("Yes, there is a match!")
else:
	print("No match")

ستكون النتيجة:
['Spain']
Yes, there is a match!
جربها بنفسك » مِن ملف regex_seq10.py
 
المجموعات
المجموعة عبارة عن مجموعة من الأحرف داخل زوج من الأقواس المرَبعة []ذات معنى خاص:

[arn]
إرجاع تطابق حيث يوجد أحد الأحرف المحددة (a أو r أو n)
مثال
import re

txt = "The rain in Spain"

#Check if the string has any a, r, or n characters:

x = re.findall("[arn]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['r', 'a', 'n', 'n', 'a', 'n']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_set1.py

[a-n]
إرجاع تطابُق لأي حرف صغير ، مِن الأبجديَّة الإنجليزية بين a و n
مثال
import re

txt = "The rain in Spain"

#Check if the string has any characters between a and n:

x = re.findall("[a-n]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['h', 'e', 'a', 'i', 'n', 'i', 'n', 'a', 'i', 'n']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_set2.py

[^arn]
إرجاع تطابُق لأي حرف باستثناء a و r و n
مثال
import re

txt = "The rain in Spain"

#Check if the string has other characters than a, r, or n:

x = re.findall("[^arn]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['T', 'h', 'e', ' ', 'i', ' ', 'i', ' ', 'S', 'p', 'i']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_set3.py

[0123]
إرجاع تطابق حيث يوجد أي من الأرقام المحددة (0 أو 1 أو 2 أو 3)
مثال
import re

txt = "The rain in Spain"

#Check if the string has any 0, 1, 2, or 3 digits:

x = re.findall("[0123]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك » مِن ملف regex_set4.py

[0-9]
إرجاع تطابق لأي رقم بين 0 و 9
مثال
import re

txt = "8 times before 11:45 AM"

#Check if the string has any digits:

x = re.findall("[0-9]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['8', '1', '1', '4', '5']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_set5.py

[0-5][0-9]
إرجاع تطابق لأي رقم من خانتين مِن 00 إلى 59
مثال
import re

txt = "8 times before 11:45 AM"

#Check if the string has any two-digit numbers, from 00 to 59:

x = re.findall("[0-5][0-9]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['11', '45']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_set6.py

[a-zA-Z]
إرجاع تطابق لأي حرف أبجدي بين a و z ، حالة حرف صغير أو كبير
مثال
import re

txt = "8 times before 11:45 AM"

#Check if the string has any characters from a to z lower case, and A to Z upper case:

x = re.findall("[a-zA-Z]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
['t', 'i', 'm', 'e', 's', 'b', 'e', 'f', 'o', 'r', 'e', 'A', 'M']
Yes, there is at least one match! 
جربها بنفسك » مِن ملف regex_set7.py

[+]
في المجموعات, +, *, ., |, (), $,{} ليس لهم معنى خاص ، لذلك [+] يعني: إرجاع تطابق لأي علامةْ + في السلسلة
مثال
import re

txt = "8 times before 11:45 AM"

#Check if the string has any + characters:

x = re.findall("[+]", txt)

print(x)

if x:
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك » مِن ملف regex_set8.py
 
 
دالة findall ()
تقوم الوظيفة findall() بإرجاع قائمة تحتوي على جميع التطابقات.
مثال
طباعة قائمة بكافة التطابقات:
import re

txt = "The rain in Spain"
x = re.findall("ai", txt)
print(x)

ستكون النتيجة:
['ai', 'ai'] 
جربها بنفسك  مِن ملف regex_findall.py
تحتوي القائمة على التطابقات بترتيب العثور عليها.
إذا لم يتم العثور على تطابقات، يتم إرجاع قائمة فارغة:
المثال
إرجاع قائمة فارغة إذا لم يتم العثور على تطابق:
import re

txt = "The rain in Spain"

#Check if "Portugal" is in the string:

x = re.findall("Portugal", txt)
print(x)

if (x):
	print("Yes, there is at least one match!")
else:
	print("No match")

ستكون النتيجة:
[]
No match 
جربها بنفسك  مِن ملف regex_findall2.py
 
 
الوظيفة search() 
تبحث الدالة search() في السلسلة عن تطابق، وتقوم بإرجاع كائن مطابقة إذا كان هناك تطابق.
إذا كان هناك أكثر من تطابق، سيتم إرجاع التواجد الأول فقط للتَطابق:
مثال
البحث عن أول حرف مسافة بيضاء في السلسلة:
import re

txt = "The rain in Spain"
x = re.search("\s", txt)

print("The first white-space character is located in position:", x.start())

ستكون النتيجة:
The first white-space character is located in position: 3 
جربها بنفسك  مِن ملف regex_search.py

إذا لم يتم العثور على تطابقات، يتم إرجاع القيمة None
مثال
إجراء بحث لا يقوم بإرجاع أي تطابق:
import re

txt = "The rain in Spain"
x = re.search("Portugal", txt)
print(x)

ستكون النتيجة:
None 
جربها بنفسك  مِن ملف regex_search2.py
 
 
الدالة split()
الدالة split() تقوم بإرجاع قائمة حيث تم تقسيم السلسلة عند كل تطابق:
مثال
تقسيم عند كل حرف مسافة بيضاء:
import re

txt = "The rain in Spain"
x = re.split("\s", txt)
print(x)

ستكون النتيجة:
['The', 'rain', 'in', 'Spain'] 
جربها بنفسك  مِن ملف regex_split.py

يمكنك التحكم في عدد مرات التقسيم عن طريق تحديد المعامِل maxsplit
مثال
تقسيم السلسلة فقط عند التواجد الأول:
import re

txt = "The rain in Spain"
x = re.split("\s", txt, 1)
print(x)

ستكون النتيجة:
['The', 'rain in Spain'] 
جربها بنفسك  مِن ملف regex_split2.py
 
 
الوظيفة sub()
الدالة sub() تستبدل التطابقات مع النص الذي تختارُه:
مثال
استبدال كل حرف مسافة بيضاء بالرقم 9:
import re

txt = "The rain in Spain"
x = re.sub("\s", "9", txt)
print(x)

ستكون النتيجة:
The9rain9in9Spain 
جربها بنفسك  مِن ملف regex_sub.py

يمكنك التحكم في عدد الاستبدالات عن طريق تحديد المعامِل count :
مثال
استبدال أول مرتين للتواجُد:
import re

txt = "The rain in Spain"
x = re.sub("\s", "9", txt, 2)
print(x)

ستكون النتيجة:
The9rain9in Spain 
جربها بنفسك  مِن ملف regex_sub2.py
 
 
كائن التطابُق(Match Object)
كائن التطابُق أو المطابقة هو كائن يحتوي على معلومات حول البحث والنتيجة.
ملاحظة: إذا لم يكن هناك تطابق، سيتم إرجاع القيمة None بدلاً من كائن المطابَقة.
مثال
القيام بالبحث الذي سيقوم بإرجاع كائن مطابَقة:
import re

txt = "The rain in Spain"
x = re.search("ai", txt)
print(x) #this will print an object

ستكون النتيجة:
<_sre.SRE_Match object; span=(5, 7), match='ai'> 
جربها بنفسك  مِن ملف regex_match.py

يحتوي كائن Match على خصائص و وظائف تُستخدم لاسترداد معلومات حول البحث ، والنتيجة:
.span() تُرجع مصفوفة(tuple) تحتوي على مواضع البداية والنهاية للتطابُق.
.stringتُرجع السلسلة التي تم تمريرها إلى الدالة
.group() إرجاع جزء السلسلة حيث كان هناك تطابق
مثال
طباعة موضع (البدء- و موضع النهاية) من تواجد التطابق الأول.
يبحث هذا ال regular expression عن أي كلمات تبدأ بحرف كبير "S":
import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.span())

ستكون النتيجة:
(12, 17) 
جربها بنفسك  مِن ملف regex_match_span.py

مثال
طباعة السلسلة التي تم تمريرها إلى الدالة:
import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.string)

ستكون النتيجة:
The rain in Spain 
جربها بنفسك  مِن ملف regex_match_string.py

مثال
طباعة الجزء من السلسلة حيث كان هناك تطابق.
يبحث ال regular expression عن أي كلمات تبدأ بحرف كبير "S":
import re

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.group())

ستكون النتيجة:
Spain 
جربها بنفسك  مِن ملف regex_match_group.py
ملاحظة: إذا لم يكن هناك تطابق ، فسيتم إرجاع القيمة None بدلاً من كائن المطابَقة.
نماذج حول التعبيرات النمطية
اضغط هنا للتنزيل

استخدام PIP في Python
ما هو PIP؟
PIP هو مدير حزمة لحُزَم Python (Python packages)، أو الوحدات النمطية إذا أردت.
ملاحظة: إذا كان لديك الإصدار 3.4 مِن Python أو إصدار أحدث ، فسيتم تضمين PIP افتراضيًا.
 
ما هي الحُزمة أو الباقة(Package)؟
تحتوي الحُزمة على جميع الملفات التي تحتاجها للوحدة النمطية.
الوحدات النمطية (modules)هي مكتبات تعليمات برمجية أو كود بلغة Python يمكنك تضمينها في مشروعك.
 
التحقق من تثبيت PIP
انتقل بِسَطر الأوامر إلى مُجلَّد script حيث تم تثبيت بايثون على حاسوبك ، واكتب ما يلي:
مثال
التحقق من إصدار PIP:
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip --version
ملاحظة خارجية:
أنت تحتاج للإنتقال بِسَطر الأوامر إلى مُجلَّد script, حيث تم تثبيت برنامج بايثون على حاسوبك
فقط , إذا كان مُثَبت على حاسوبك أكثر مِن إصدار لبرنامج بايثون.
أما إذا لم يكن على حاسوبك إلا إصدار واحد لبايثون,  و هذا ما يكون في أغلب الأحيان
فَلا داعي للإنتقال بِسَطر الأوامر,بَل تستطيع أن تفتح سطر الأوامر في أي مكان, مثلا مُجلَّد المستخدم و تكتُبْ عليه:
pip --version
و سيقول لك نسخةْ pip الموجودة عندك.

 تثبيت PIP
إذا لم يكن لديك PIP مثبتًا ، فيمكنك تنزيله وتثبيته من هذه الصفحة: 
https://pypi.org/project/pip/
 
تنزيل حُزمة(Package)
تنزيل الحُزمة سهل لِلغاية.
افتحْ واجهة سطر الأوامر واطلب من PIP تنزيل الحزمة التي تريدها.
الأمر الأساسي لتنزيل حُزمة
pip install packageName
و packageName هو اسم الحُزمة التي نريد تنزيلها.

انتقل بِسَطر الأوامر إلى مُجلَّد script حيث تم تثبيت بايثون على حاسوبك ، واكتب ما يلي:
ملحوظة: في حال وجود إصدار واحد مِن بايثون عندك,لا داعي للإنتقال إلى مُجلَّد script, بَل تستطيع أن تفتح سطر الأوامر و تكتب عليه فورا أوامر pip.
مثال
تنزيل حُزمة تسمى "camelcase":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip install camelcase
الآن قمتَ بتنزيل وتثبيت الحزمة الأولى الخاصة بك!
  
استخدام الحُزمة(Package)
بمجرد تثبيت الحُزمة ، تصبح جاهزة للاستخدام.
استيراد حزمة "camelcase" إلى مشروعك.
مثال
استيراد واستخدام "camelcase":
import camelcase

c = camelcase.CamelCase()

txt = "hello world"

print(c.hump(txt))
#This method capitalizes the first letter of each word.
# هذه الوظيفة تُحَوِّل أول حرف مِن كل كلمة إلى حرف كبير.

ستكون النتيجة:
Hello World
تشغيل مثال » مِن ملف camelcase.py
 
البحث عن الحُزَم
ابحث عن المزيد من الحُزَم على https://pypi.org/ .
 
إزالةُ حُزمة(Remove a Package)
استخدِمْ الأمر uninstall لإزالة الحُزمة:
مثال
قم بإلغاء تثبيت الحُزمة المسماة "camelcase":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip uninstall camelcase
سيَطلب منك PIP Package Manager تأكيد رغبتك في إزالة حزمة camelcase:
Uninstalling camelcase-02.1:
  Would remove:
    c:\users\Your Name\appdata\local\programs\python\python36-32\lib\site-packages\camecase-0.2-py3.6.egg-info
    c:\users\Your Name\appdata\local\programs\python\python36-32\lib\site-packages\camecase\*
Proceed (y/n)?
اضغط yوستتم إزالة الحزمة.
 ملحوظة y ومِن بعدها إنتر طبعا.
 
قائمة الحُزَم(List Packages)
استخدم الأمر list لإظهار جميع الحُزَم المثبتة على نظامك:
مثال
قائمة الحُزَم المثبتة:
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip list
نتيجة:
Package         Version
-----------------------
camelcase       0.2
mysql-connector 2.1.6
pip             18.1
pymongo         3.6.1
setuptools      39.0.1

تلميحات خارجية:
 إذا كنت تريد أن تعرف أين مُثَبت بايثون على حاسوبك, إفتحْ سطر الأوامر واكتب عليه:
 where python
 و إذا كان يوجد عندك أكثر مِن إصدار, فسيقول لك مسار الإصدارات جميعها.
 مثال:
 C:\Users\ibra>where python
C:\Python27\python.exe
C:\Users\ibra\AppData\Local\Programs\Python\Python37-32\python.exe

نماذج حول التعامل مع أداة pip
اضغط هنا للتنزيل

Try Except في بايثون
تتيح لك كتلةْ try اختبار كتلة من التعليمات البرمجية للأخطاء.
و كتلةْ except تتيح لك التعامل مع الخطأ.
و كتلة finally تتيح لك تنفيذ التعليمات البرمجية، بغض النظر عن نتيجةْ الكُتَل try- except .
 ملحوظة: الكتلة نعني بها مجموعة مِن الأسطر البرمجية في بايثون, و تكون في نطاق معين
 فالأسطر تحت try, نقول لها كتلةْ try, و تحت except كتلةْ except, و كذلك finally.
 
التعامل مع ال Exception(الإستثناء)
عند حدوث خطأ أو Exception كما نسميه ، سيتوقف Python عادةً وينشئ رسالة خطأ.
يمكن التعامل مع هذه الاستثناءاتExceptions باستخدام عبارة try:
مثال
سوف تُنشئ كتلة try خطأ أو Exception، لأن xلم يتم تعريفُه:
try:
	print(x)
except:
	print("An exception occurred")

ستكون النتيجة:
An exception occurred 
جربها بنفسك  مِن ملف try_except.py
نظرًا لأن كتلةْ try تثيرُ خطأً ، فسيتم تنفيذ كتلةْ except.
بدون كتلةْ try ، سيتعطل البرنامج ويثير خطأً:
مثال
ستُثير هذه العبارة خطأ ، لأنَّ xلم يتم تعريفُه:
print(x)

ستكون النتيجة:
Traceback (most recent call last):
  File "try_except_error.py", line 3, in 
    print(x)
NameError: name 'x' is not defined 
جربها بنفسك  مِن ملف try_except_error.py
 
أكثر مِن استثناء أو Exception
يمكنك تحديد العديد من كتل except كما تريد ، 
على سبيل المثال ، إذا كنتَ تريد تنفيذ كتلة خاصة مِن التعليمات البرمجية لنوع خاص من الخطأ:
مثال
طباعة رسالة معينة إذا كانت كتلةْ try تثير NameError ورسالة أخرى لأخطاء أخرى:
try:
	print(x)
except NameError:
	print("Variable x is not defined")
except:
	print("Something else went wrong")

ستكون النتيجة:
Variable x is not defined 
جربها بنفسك  مِن ملف try_except2.py
 
 
Else
يمكنك استخدام الكلمة الرئيسية else لتحديد كتلة من التعليمات البرمجية ليتم تنفيذها إذا لم يتم حدوث أي أخطاء:
مثال
في هذا المثال ، لا تُولد كتلة try أي خطأ:
try:
	print("Hello")
except:
	print("Something went wrong")
else:
	print("Nothing went wrong")

ستكون النتيجة:
Hello
Nothing went wrong 
جربها بنفسك  مِن ملف try_except3.py
 
Finally
سيتم تنفيذ الكتلة finally ، إذا تم وضعها ، بغض النظر عما إذا كانت كتلة try تثير خطأ أم لا.
مثال
try:
	print(x)
except:
	print("Something went wrong")
finally:
	print("The 'try except' is finished")

ستكون النتيجة:
Something went wrong
The 'try except' is finished 
جربها بنفسك  مِن ملف try_except4.py
يمكن أن يكون هذا الأُسلوب مفيدًا في إغلاق الكائنات وتنظيف الموارد:
مثال
حاوِل فتح ملف غير قابل للكتابة والكتابة فيه:
try:
	f = open("demofile.txt")
	f.write("Lorum Ipsum")
except:
	print("Something went wrong when writing to the file")
finally:
	f.close()

ستكون النتيجة:
Something went wrong when writing to the file 
جربها بنفسك  مِن ملف try_except5.py
الآن يمكن أن يستمر البرنامج ، دون ترك كائن الملف مفتوحا.
 
Raise an exception(عمل Exception بشكل متعمد)
كمطور بيثون يمكنك اختيار إثارةْ أو عمل Exception في حالة حدوث شرط معين.
لطرح (أو عمل) Exception ، استخدم الكلمة الرئيسية raise.
مثال
إثارةْ خطأ وإيقاف البرنامج إذا كان x أقل من 0:
x = -1

if x < 0:
	raise Exception("Sorry, no numbers below zero")

ستكون النتيجة:
Traceback (most recent call last):
  File "ref_keyword_raise.py", line 4, in 
    raise Exception("Sorry, no numbers below zero")
Exception: Sorry, no numbers below zero 
جربها بنفسك مِن ملف ref_keyword_raise.py
يتم استخدام الكلمة الرئيسية raise لعمل خطأ أو Exception.

يمكنك تحديد نوع الخطأ الذي تريد طرحه والنص الذي سيتم طباعته للمستخدم.
مثال
إثارةْ أو إحداث TypeError إذا لم يكن x عددًا صحيحًا:
x = "hello"

if not type(x) is int:
	raise TypeError("Only integers are allowed")

ستكون النتيجة:
Traceback (most recent call last):
  File "ref_keyword_raise2.py", line 4, in 
    raise TypeError("Only integers are allowed")
TypeError: Only integers are allowed 
جربها بنفسك  مِن ملف ref_keyword_raise2.py
 
نماذج حول الخطأ والاستثناء
اضغط هنا للتنزيل

إدخال المستخدم(User Input)
نعني هنا بإدخال المستخدم أو user input, هو إمكانية إدخال المستخدم لبيانات معينة في البرنامج.

إدخال المستخدم(User Input)
تسمح لغة Python بإدخال المستخدم.
هذا يعني أننا قادرون على مطالبة المستخدم بالإدخال بيانات معينة.
تختلف الطريقة قليلاً في Python 3.6 عن Python 2.7.
بيثون 3.6 يستخدم لهذا الأمر الوظيفة input().
أما Python 2.7 فيستخدم الوظيفة raw_input()
يطلب المثال التالي اسم المستخدم ، وعند إدخال اسم المستخدم ، يتم طباعته على الشاشة:
بيثون 3.6
username = input("Enter username:")
print("Username is: " + username)

النتيجة عندي:
Username is: ibrahim
تشغيل المثال » مِن ملف user_input3.py

بايثون 2.7
username = raw_input("Enter username:")
print("Username is: " + username)

النتيجة عندي:
Username is: ibrahim
تشغيل المثال » مِن ملف user_input2.py
يتوقف Python عن التنفيذ عندما يصل إلى  الوظيفة input () ، و ذلك لِيسمح للمستخدِم بإدخالِ البيانات.
ثُمَّ يستمر عندما ينتهي المستخدِم مِن إدخال البيانات.
 
نماذج حول إدخال المستخدِم
اضغط هنا للتنزيل

تنسيق السلسلة في بيثون(String Formatting)
السلسلة هنا نشير بها إلى السلسلة النصِّيَّة(string).

للتأكد من عرض سلسلة كما هو متوقع ، يمكننا تنسيق النتيجة باستخدام الوظيفة format ().
 
الدالة format() الخاصة بتنسيق السلسلة
 تسمح لك الوظيفة format() بتنسيق أجزاء مختارة من سلسلة.
في بعض الأحيان تُوجد أجزاء من النص لا تستطيع أن تتحكم فيها ، ربما تأتي من قاعدة بيانات أو من مُدْخَلات المستخدم؟
للتحكم في هذه القيم، أضف عناصر نائبة عنها (أقواس متعرِّجَة {}) في النص، 
ثُم قم بتشغيل القيم من خلال الوظيفة format() :
مثال
أضف عنصرًا نائبًا(placeholder) حيث تريد عرض السِعْر:
price = 49
txt = "The price is {} dollars"
print(txt.format(price))

ستكون النتيجة:
The price is 49 dollars 
جربها بنفسك  مِن ملف string_formatting1.py

يمكنك إضافةْ مُعامِلات داخل الأقواس المتعرِّجة لتحديد كيفية تحويل القيمة:
مثال
قم بتنسيق السِعْر ليتم عرضه كرقم مع رقمين عشريين, أي رقمين بعد الفاصلة:
price = 49
txt = "The price is {:.2f} dollars"
print(txt.format(price))

ستكون النتيجة:
The price is 49.00 dollars 
لاحِظ الصِفرَين بعد الفاصلة
جربها بنفسك  مِن ملف string_formatting2.py
يمكنك الإطِّلاع على جميع أنواع التنسيقات التي يمكن أن تستخدمها مِن مرجع String format() :
من هنا
 
استخدام القيم المتعددة
إذا كنتَ تريد استخدام المزيد من القيم ، فما عليك سوى إضافة المزيد من القيم إلى الوظيفة format ():
print(txt.format(price, itemno, count))
وأضف المزيد من العناصر النائبة(placeholders) في السلسلة:
مثال
quantity = 3
itemno = 567
price = 49
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))

ستكون النتيجة:
I want 3 pieces of item number 567 for 49.00 dollars. 
جربها بنفسك  مِن ملف string_formatting3.py
 
استخدام أرقام الموضع أو الفهرس(Index Numbers)
يمكنك استخدام أرقام الفهرس أو الموضع (رقم داخل الأقواس المتعرِّجَة {0}) للتأكد من وضع القيم في العناصر النائبة الصحيحة:
مثال
quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

ستكون النتيجة:
I want 3 pieces of item number 567 for 49.00 dollars. 
جربها بنفسك  مِن ملف string_formatting4.py

أيضًا ، إذا كنتَ تريد الإشارة إلى نفس القيمة أكثر من مرة ، فاستخدم رقم الفهرس:
مثال
age = 36
name = "John"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

ستكون النتيجة:
His name is John. John is 36 years old. 
جربها بنفسك  مِن ملف string_formatting5.py
 
الفهارس المسماةْ(Named Indexes)
و نعني بها جعل إسم للموضع بدل الرقم.
و هكذا يمكنك أيضًا استخدام الفهارس المسماة عن طريق إدخال اسم داخل الأقواس المتعرِّجَة {carname}، 
ولكن بعد ذلك يجب عليك استخدام الأسماء عند تمرير قيم المعامِلات txt.format(carname = "Ford"):
مثال
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Ford", model = "Mustang"))

ستكون النتيجة:
I have a Ford, it is a Mustang. 
جربها بنفسك  مِن ملف string_formatting6.py
 
نماذج حول تنسيق السلاس النصية
اضغط هنا للتنزيل

فتح الملفات في Python

تعتبر معالجة الملفات جزءًا مهمًا من أي تطبيق ويب.
يحتوي Python على العديد من الوظائف لإنشاء الملفات وقراءاتها وتحديثها و حذفِها.
 
التعامل مع الملفات
الوظيفة الأساسية للعمل مع الملفات في بايثون هي الوظيفة open().
تأخذ وظيفة open () معاملَين ؛ 
اسم الملف ، والوضع(mode).
ال mode هو الوضع أو النمط أو الصيغة التي نريد أن نفتح بها الملف.
توجد أربع أنماط (أوضاع) مختلفة لفتح ملف:
"r"- لِقراءةْ الملف
-و هي  القيمة الافتراضية. سيُفتَح الملف للقراءة ، ستُرجع خطأ إذا كان الملف غير موجود
"a" - إلحاق 
- فتح ملف للإلحاق ، و يقوم بإنشاء الملف إذا لم يكن موجودًا
"w" - كتابة 
- فتح ملف للكتابة ، و يقوم بإنشاء الملف إذا لم يكن موجودًا
"x" - إنشاء 
- إنشاء الملف المحدد ، وإرجاع خطأ إذا كان الملف موجودًا
بالإضافة إلى ذلك ، يمكنك تحديد ما إذا كان يجب معالجة الملف كوضع ثنائي(binary) أو وضعْ نصي(text)
"t"- نص - القيمة الافتراضية. وضع النص
"b" - ثنائي(binary) - الوضع الثنائي (مثل الصور)
 
طريقةْ فتح الملف
لِفتح ملف لقراءتِه يكفي تحديد اسم الملف:
f = open("demofile.txt") 
الكود أعلاه هو نفسه:
f = open("demofile.txt", "rt") 
لأن "r" للقراءة و "t" للنص, هي القيم الافتراضية، لا تحتاج إلى تحديدها.
ملاحظة: تأكدْ من وجود الملف ، وإلا فسوف تحصل على خطأ.
 
القراءة من  الملفات في بيثون
فتح ملف في نفس المُجَلَّد
نفترض أن لدينا الملف التالي ، الموجود في نفس المُجَلَّد الذي يعمل فيه بيثون, أو نحن موجودون فيه:
demofile.txt
Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck!

لِفتح الملف ، استخدم وظيفة open () المضمنة, أو الموجودة في بايثون.
تقوم الدالة open() بإرجاع كائن ملف ، والذي يحتوي على طريقة read () لقراءة محتوى الملف:
مثال
f = open("demofile.txt", "r")
print(f.read())

ستكون النتيجة:
Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck! 
تشغيل المثال » مِن ملف file_open.py

إذا كان الملف موجودًا في موقع مختلف ، فسيتعين عليك تحديد مسار الملف ، مثل هذا:
مثال
افتح ملفًا في موقع مختلف:
f = open("D\\myfiles\welcome.txt", "r")
# الملف موجود في المُجَلَّد D\myfiles
print(f.read())

النتيجة:
Welcome to this text file!
This file is located in a folder named "myfiles", in the folder D
Good Luck! 
تشغيل المثال » مِن ملف file_open_d.py 
 
قراءة أجزاء فقط من الملف
تقوم الطريقة read() افتراضيًا بقراءةْ أو إرجاع النص بالكامل ، 
ولكن يمكنك أيضًا تحديد عدد الأحرف التي تريد إرجاعهاأو قراءتها:
مثال
إرجاع الأحرف الخمسة الأولى من الملف:
f = open("demofile.txt", "r")
print(f.read(5))

ستكون النتيجة:
Hello
تشغيل مثال » مِن ملف file_open2.py
 
 
قراءة الأسطر في الملف
يمكنك إرجاع سطر واحد باستخدام الطريقة readline()
المثال
اقرأ سطرًا واحدًا من الملف:
f = open("demofile.txt", "r")
print(f.readline())

ستكون النتيجة:
Hello! Welcome to demofile.txt
تشغيل مثال » مِن ملف file_readline.py

بواسطة استدعاء readline() مرتين، يمكنك قراءة السطرين الأولين مِن الملف:
المثال
قراءة سطرين من الملف:
f = open("demofile.txt", "r")
print(f.readline())
print(f.readline())

ستكون النتيجة:
Hello! Welcome to demofile.txt
This file is for testing purposes.
تشغيل مثال » مِن ملف file_readline2.py

مِن خلال عمل حلقة على  سُطور الملف ، يمكنك قراءة الملف بالكامل ، سطراً سطراً:
مثال
عمل حلقة خلال الملف سطرًا سطراً:
f = open("demofile.txt", "r")
for x in f:
	print(x)

ستكون النتيجة:
Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck!
تشغيل مثال » مِن ملف file_readline3.py
 
إغلاق الملفات
يُعد إغلاق الملف دائمًا عند الانتهاء منه ممارسة جيدة.
مثال
أغلقْ الملف عند الانتهاء منه:
f = open("demofile.txt", "r")
print(f.readline())
f.close()
# هذه المرة أغلقنا الملف بالوظيفة close().

النتيجة:
Hello! Welcome to demofile.txt
تشغيل مثال » مِن ملف file_close.py
و هكذا في الكود السابق, يكون الملف demofile.txt قد أُغلِق. 
ملاحظة: يجب عليك دائمًا إغلاق ملفاتك بعد الإنتهاء مِن العمل بها. 
في بعض الحالات ، بسبب التخزين المؤقت ، قد لا تظهر التغييرات التي تم إجراؤها على الملف حتى تقوم بإغلاق الملف.
 
نماذج حول القراءة من الملفات
اضغط هنا للتنزيل

الكتابة في ملف 
 
الكتابة إلى ملف موجود
للكتابة إلى ملف موجود ، يجب إضافة معامل إلى الوظيفة open()
المُعامِل يمكن أن يكون:
"a" - إلحاق - سيتم إلحاق المحتوى في نهاية الملف
"w" - الكتابة - سيتم الكتابة فوق أي محتوى موجود, و هذا يعني إزالةْ المحتوى الموجود سابقا.
مثال
فتح الملف " demofile2.txt " وإلحاق المحتوى إلى الملف:
f = open("demofile2.txt", "a")
f.write("Now the file has more content!")
f.close()

#open and read the file after the appending:
f = open("demofile2.txt", "r")
print(f.read())

ستكون النتيجة:
Hello! Welcome to demofile2.txt
This file is for testing purposes.
Good Luck!Now the file has more content! 
تشغيل المثال مِن ملف demo_file_append.py

مثال
افتح الملف "demofile3.txt" واستبدل المحتوى:
f = open("demofile3.txt", "w")
f.write("Woops! I have deleted the content!")
f.close()

#open and read the file after the writing:
f = open("demofile3.txt", "r")
print(f.read())

ستكون النتيجة:
Woops! I have deleted the content! 
تشغيل المثال مِن ملف demo_file_write.py
ملاحظة: سوف تقوم الطريقة "w" بالكتابة فوق الملف بأكمله. يعني إزالةْ أي محتوى سابق فيه.
 
إنشاء ملف جديد
لإنشاء ملف جديد في Python ، استخدم طريقة open () ، مع إحدى المعامِلات التالية:
"x" - إنشاء - سيتم إنشاء ملف ، وإرجاع خطأ إذا كان الملف موجودا
"a" - إلحاق - سيتم إنشاء ملف إذا لم يكن الملف المحدد موجودا
"w" - الكتابة - سيتم إنشاء ملف إذا لم يكن الملف المحدد موجودا
مثال
قم بإنشاء ملف يسمى "myfile.txt":
f = open("myfile.txt", "x")
النتيجة: 
إنشاء ملف فارغ جديد! و سيكون اسمه myfile.txt
و سيكون الملغ موجودا طبعا في نفس المُجَلَّد الذي نحن فيه.

مثال
إنشاء ملف جديد إذا لم يكن موجوداً:
f = open("myfile.txt", "w")
 
و بهذه الطريقة
إذا كان الملف myfile.txt موجودا, سنفتحه و نكتب فوق محتواه.
و إذا لم يكن موجودا, سيتم إنشاءه نِن عَدَم, ثُمَّ نستطيع أن نكتب فيه ما نشاء.

نماذج حول الكتابة في الملفات
اضغط هنا للتنزيل

حذف الملفات في بايثون
حذف ملف
لِحذف ملف ، يجب عليك استيراد مكتبةْ os, و استخدام الوظيفة remove()التي فيها:
مثال
قم بإزالة الملف "demofile.txt":
import os
os.remove("demofile.txt")
 
 النتيجة:
 سيتم إزالةْ الملف إذا كان بالفعل موجودًا.
 ملاحظة: إذا لم يكن هناك ملف موجود بهذا الإسم, فإنَّ بايثون سيعترض عليك و يُعطي خطأ.
 
التحقق من وجود الملف:
لتجنب حدوث خطأ ، قد ترغب في التحقق مما إذا كان الملف موجودًا قبل محاولةْ حذفِه:
مثال
تحقق مما إذا كان الملف موجودا، ثم احذفه:
import os
if os.path.exists("demofile.txt"):
	os.remove("demofile.txt")
else:
	print("The file does not exist")
 
 النتيجة:
 إذا كان الملف موجودا سيتم حذف, و إذا لم يكن موجودا, سيكتب لك
 The file does not exist
 
حذف المُجَلَّد
لحذف مجلَّد بأكمله، استخدم الدالة os.rmdir() :
مثال
قم بإزالة المُجَلَّد "myfolder":
import os
os.rmdir("myfolder")

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