معالجة الأخطاء:

Pass تعني عدم وجود عملية للتنفيذ.
تستطيع سرد أكثر من نوع خطأ في جملة except.
تستطيع استخدام جملة else مع try/except اختياريا (تنفذ في حالة كانت الشفرة البرمجية في try لم تُصدر أي خطأ).
نستخدم جملة finally لتنفيذ شفرة برمجية بعد try/except بغض النظر عن وجود أخطاء أم لا، وعادةً يُعاد تحرير المصادر المستخدمة.
بدلا من استخدام جملة finally لإعادة تحرير المصادر المستخدمة، تستطيع استخدام جملة with:

with open("myfile.txt") as f:
for line in f:
print(line)
تُقدم البايثون كائنًا متُعددًا (Iterable) وهو كائن مجرد (عام) يُتعامل معه مثل sequence. فمثلا الكائن المُرجع من الدالة range هو كائن مُتعدد:

filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
print(our_iterable) # => dict_keys(['one', 'two', 'three']).
تستطيع المرور على عناصر الكائن المتعدد والتعامل معها:

for i in our_iterable:
print(i) # Prints one, two, three
على الرغم من خاصية الكائن المتعدد، إلا أنه لا تستطيع استخدام الفهرس معه:

our_iterable[1] # Raises a TypeError
تستطيع الحصول من خلال الكائن المُتعدد على كائن iterator منه بحيث تستطيع المرور على عناصره:

our_iterator = iter(our_iterable)
يحتفظ الكائن iterator بحالته كلما تم استخدامه، فمثلا، باستخدام وظيفة next تستطيع الحصول على العنصر التالي في هذا الكائن:

next(our_iterator) # => "one"
next(our_iterator) # => "two"
next(our_iterator) # => "three"
بعد الحصول على كافة عناصر iterator فإن استخدام الدالة next سيعيد خطأ:

next(our_iterator) # Raises StopIteration
تستطيع الحصول على كافة عناصر iterator دفعة واحدة على شكل قائمة وذلك باستخدام الدالة list :

list(filled_dict.keys()) # => Returns ["one", "two", "three"]
الدوال
نستخدم الكلمة def في تعريف الدالة، ونستخدم كلمة return في إرجاع النتيجة:

def add(x, y):
print("x is {} and y is {}".format(x, y))
return x + y
تطبع الدالة السابقة قيمتيْ المعامليْن المُمرّرين لها وتعيد ناتج جمعهما:

add(5, 6) # => prints out "x is 5 and y is 6" and returns 11
يمكن أيضا استدعاء الدالة بذكر أسماء المعاملات (شرط الترتيب غير مطلوب هنا للمعاملات):

add(y=6, x=5)
تستطيع تعريف دالة باستقبال عددًا غير محدد من المعاملات:

def varargs(*args):
return args

varargs(1, 2, 3) # => (1, 2, 3)
من الممكن استخدام المعاملات المُسماة لاستقبال عدد غير محدد من المعاملات أيضا:

def keyword_args(**kwargs):
return kwargs

keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}
كما نستطيع دمج الطريقتين في نفس الدالة:

def all_the_args(*args, **kwargs):
print(args)
print(kwargs)
all_the_args(1, 2, a=3, b=4) # =>
(1, 2)
{"a": 3, "b": 4}
توجد طريقة أخرى لاستدعاء الدوال باستخدام args/kwargs وذلك عندما تكون المعطيات من النوع tuple أو قاموس:

args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # equivalent to foo(1, 2, 3, 4)
all_the_args(**kwargs) # equivalent to foo(a=3, b=4)
all_the_args(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4)
يمكن أيضا إرجاع نتيجة من قيم متعددة على شكل tuple:

def swap(x, y):
return y, x

x = 1
y = 2
x, y = swap(x, y) # => x = 2, y = 1
يختلف المتغيّر في نطاق scope الدالة عن المتغيّرات العامة Global:

x = 5
def set_x(num):
x = num # => 43
print(x) # => 43
تُستخدَم الكلمة المفتاحية global لتعريف متغيّر عام من داخل الدالة:

def set_global_x(num):
global x
print(x) # => 5
x = num # هذا المتغير يمثل المتغير على النطاق العام وقيمته الان 6
print(x) # => 6

set_x(43)
set_global_x(6)
تعدّ الدوال في بايثون كائنات من الفئة الأولى:

def create_adder(x):
def adder(y):
return x + y
return adder

add_10 = create_adder(10)
add_10(3) # => 13
كما يمكنك تعريف دوال غير مسمّاة Anonymous functions:

(lambda x: x > 2)(3) # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
ويمكنك تمرير الدالة معاملا لدالة أخرى:

list(map(add_10, [1, 2, 3])) # => [11, 12, 13]
list(map(max, [1, 2, 3], [4, 2, 1])) # => [4, 2, 3]

list(filter(lambda x: x > 5, [3, 4, 5, 6, 7])) # => [6, 7]
تستطيع استخدام مبدأ “تفهيم القائمة” للحصول على نفس نتيجة الدوال map و filter:

[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
تستطيع استخدام مبدأ “تفيهم القاموس” و “تفهيم المجموعة” كذلك:

{x for x in 'abcddeef' if x not in 'abc'} # => {'d', 'e', 'f'}
{x: x**2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
الوحدات Modules
الوحدات في بايثون عبارة عن ملفات بايثون عادية. تستطيع أن تكتب الوحدة الخاصة بك وتستوردها في الشفرة البرمجة الخاصة بمشروعك. اسم الوحدة سيكون نفس اسم الملف الذي أنشأته لهذا الغرض.
تُستورَد الوحدات بالطريقة التالية:

import math
print(math.sqrt(16)) # => 4.0
تستطيع الحصول على دوال محددة من الوحدات:

from math import ceil, floor
print(ceil(3.7)) # => 4.0
print(floor(3.7)) # => 3.0
تستطيع استيراد جميع الدوالّ من الوحدة دفعة واحدة ولكن هذا الأمر غير منصوح به:

from math import *
تستطيع اختصار أسماء الوحدات عند استيرادها:

import math as m
math.sqrt(16) == m.sqrt(16) # => True
تُستخدَم الدالة المضمنة dir لمعرفة مكان ملف الوحدة.

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

الأصناف Classes
نستخدم كلمة class لتعريف صنف:

class Human:
لتعريف خاصية للصنف (هذه الخاصية تكون مُشاركة بين كل العناصر المتولدة من هذا الصنف):

species = "H. sapiens"
init هو المشيّدات Constructor الأساسي ويُستدعى عند توليد عنصر من الصنف. التسطير السفلي المكرر مرتين قبل كلمة init وبعدها يدل على أن هذا الكائن أو الخاصية يستخدمه بايثون ولا يجب علينا استخدامها مباشرة.

def __init__(self, name):
# إعطاء قيمة المعطى للخاصية الموجودة في الصنف
self.name = name

# قيمة مبدئية
self._age = 0
الدالة say هي تابع عيّنة Instance method، أي أن لكل كائن نسخة خاصة به منها. تأخذ هذه التوابع أن self في أول معامل يُمرّر لها:

def say(self, msg):
print ("{name}: {message}".format(name=self.name, message=msg))

def sing(self):
return 'yo... yo... microphone check... one two... one two...'
يمكن أيضا تعريف تابع متشارك بين كل كائنات الصنف:

@classmethod
def get_species(cls):
return cls.species
نستطيع كذلك تعريف تابع ساكن يُستدعى دون الحاجة لإنشاء كائن من الصنف:

@staticmethod
def grunt():
return "*grunt*"
يحوّل التعليمة property@ دالة إلى خاصيّة للقراءة فقط لها نفس اسم الدالة، لتؤدّي بالتالي وظيفة المسترجعات Getters.

@property
def age(self):
return self._age
يمكننا جعل الخاصية قابلة للتعيين لتصبح الدالة تعمل معدّلا Setter:
@age.setter
def age(self, age):
self._age = age
كما يمكننا السماح بحذفها:

@age.deleter
def age(self):
del self._age
يقوم مُفسر البايثون بتنفيذ كافة اشيفرة البرمجية في ملف الوحدة الذي يقرأه، ومن خلال الخاصية name نتأكد من أن كتلة الشفرة البرمجية التي في جملة الشرط ستُنفَّذ في حال كانت الوحدة هي البرنامج الرئيسي المُنفذ:

if __name__ == '__main__':
i = Human(name="Ian")
i.say("hi") # "Ian: hi"
j = Human("Joel")
j.say("hello") # "Joel: hello"

# استدعاء دالة الفئة
i.say(i.get_species()) # "Ian: H. sapiens"

# تغيير الخاصية المشتركة
Human.species = "H. neanderthalensis"
i.say(i.get_species()) # => "Ian: H. neanderthalensis"
j.say(j.get_species()) # => "Joel: H. neanderthalensis"

# استدعاء الدالة الساكنة
print(Human.grunt()) # => "*grunt*"
لا تستطيع استدعاء الدالة الساكنة من خلال العنصر المتولد i لأن استدعاءها بهذه الطريقة سيضيف self كمعامل لها مما سينتج عنه خطأ:

print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given

i.age = 42
i.say(i.age) # => "Ian: 42"
j.say(j.age) # => "Joel: 0"
del i.age
# i.age # => this would raise