دورة بايثون مكثفة للمبرمجين: دليلك الشامل للانطلاق السريع

7 min read Aldawsari
دقائق القراءة: 7

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

جدول المحتويات

إعداد البيئة

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

أهلاً بالعالم (Hello World)

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

print( "Hello world" )

لحفظ البرنامج، استخدم الامتداد .py (على سبيل المثال، hello.py). لتشغيله، افتح الطرفية ونفّذ الأمر python3 hello.py. في هذا الدليل، سنعتمد على python3، حيث تم إيقاف دعم python2 بحلول عام 2020، لذا من الأفضل دائمًا استخدام أحدث إصدار.

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

في بايثون، يمكن أن تحتوي المتغيرات على أحرف وأرقام وشرطات سفلية (underscores). لنستعرض الأنواع الأساسية للبيانات.

السلاسل النصية (Strings)

السلاسل النصية هي تسلسلات من الأحرف. يمكن تعريفها باستخدام علامات اقتباس مفردة أو مزدوجة.

# هذا تعليق في بايثون
msg_from_computer = "Hello" # سلسلة نصية
another_msg = 'Hello in single quote' # هذه أيضًا سلسلة نصية.
print(msg_from_computer + " World..!") # دمج السلاسل النصية
print(type(msg_from_computer)) # ستعيد الدالة type() نوع البيانات.

كما ترى، يمكن دمج السلاسل النصية باستخدام عامل التشغيل +. الدالة type() مفيدة جدًا لتحديد نوع أي متغير.

الأعداد الصحيحة (Numbers)

تدعم بايثون العمليات الحسابية الأساسية على الأعداد الصحيحة.

2
2 * 3
2 ** 7 # الأس (2 مرفوعة للقوة 7)
(2 + 3) * 4

الأعداد العشرية (Floats)

تُستخدم الأعداد العشرية لتمثيل الأرقام ذات الكسور.

2.7
0.1 + 0.2 # الناتج 0.30000000000000004 بسبب دقة الفاصلة العائمة
2 * 0.1 # الناتج 0.2

كن حذرًا عند الدمج (Concatenation):

لا يمكنك دمج سلسلة نصية مع عدد صحيح مباشرة. يجب تحويل العدد إلى سلسلة نصية أولاً.

count = 5
# print("I need" + count + "chocolates") # هذا السطر سيسبب خطأ لأن count عدد صحيح
print("I need" + str(count) + " chocolates") # هذا سيعمل بشكل صحيح بعد التحويل باستخدام str()

القيم المنطقية (Bool)

القيم المنطقية تمثل إما True (صحيح) أو False (خطأ). لاحظ أن الحرف الأول يجب أن يكون كبيرًا.

True # صحيح
False # خطأ
bool("some value") # تعيد True (لأن السلسلة غير فارغة)
bool("") # تعيد False (لأن السلسلة فارغة)
bool(1) # تعيد True (لأن العدد غير صفر)

القوائم (Lists)

القوائم في بايثون تشبه المصفوفات في لغات أخرى، وهي مجموعات مرتبة وقابلة للتعديل (mutable).

numbers = ["one", "two", "three"]
numbers[0] # الوصول للعنصر الأول: "one"
numbers[-1] # الوصول للعنصر الأخير: "three". بايثون تبدأ العد من النهاية عند استخدام قيم سالبة.
numbers[-2] # الوصول للعنصر قبل الأخير: "two"
len(numbers) # 3. تعيد طول القائمة.
numbers.append("four") # تضيف العنصر إلى نهاية القائمة: ["one", "two", "three", "four"]
numbers.insert(1, "wrong_one") # تُدرج القيمة في الموضع المحدد: ["one", "wrong_one", "two", "three", "four"]

# حذف القيم
del numbers[1] # تحذف القيمة في الموضع المحدد: ["one", "two", "three", "four"]
popped_element = numbers.pop() # تحذف وتُعيد العنصر الأخير: popped_element = "four", numbers = ["one", "two", "three"]
numbers.remove("two") # تحذف أول ظهور للقيمة: ["one", "three"]

# الفرز (Sorting)
alpha = ["z", "c", "a"]
alpha.sort() # الفرز الدائم: alpha = ["a", "c", "z"]
alpha.sort(reverse=True) # الفرز العكسي الدائم: alpha = ["z", "c", "a"]

alpha = ["z", "c", "a"]
print(sorted(alpha)) # ["a", "c", "z"]. تعيد قائمة مفروزة دون تعديل الأصل.
print(alpha) # ["z", "c", "a"]. القائمة الأصلية لم تتغير.

# عكس الترتيب (Reversing)
nums = [10, 1, 5]
nums.reverse() # تعكس ترتيب العناصر: [5, 1, 10]. لا تقوم بالفرز، بل تعكس الترتيب الزمني.

# تقطيع القوائم (Slicing)
alpha = ['a', 'b', 'c', 'd', 'e']
alpha[1:3] # ['b', 'c']. تبدأ من الفهرس الأول وتتوقف قبل الثاني.
alpha[2:5] # ['c', 'd', 'e']
alpha[:4] # ['a', 'b', 'c', 'd']. تبدأ من البداية إذا لم يحدد الفهرس الأول.
alpha[3:] # ['d', 'e']. تستمر حتى النهاية إذا لم يحدد الفهرس الأخير.
alpha[:] # ['a', 'b', 'c', 'd', 'e']. نسخة كاملة من القائمة.

عند نسخ قائمة باستخدام alpha[:]، فإن أي تغييرات في القائمة الأصلية لن تؤثر على النسخة. لكن، إذا قمت بتعيين قائمة لأخرى مثل another_alpha = alpha، فإن أي تغيير في alpha سيؤثر أيضًا على another_alpha، لأنها تشير إلى نفس الكائن في الذاكرة.

المجموعات غير القابلة للتعديل (Tuples)

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

nums = (1, 2, 3)
print(nums) # (1, 2, 3)
print(nums[0]) # 1
print(len(nums)) # 3
empty_tuple = () # مجموعة فارغة بطول صفر.
num = (1,) # ملاحظة الفاصلة الزائدة. عند تعريف عنصر واحد في مجموعة، أضف فاصلة بعده.
# num = (1) # print(type(num)) # . لن تعيد مجموعة لأن لا توجد فاصلة زائدة.

# إنشاء مجموعة جديدة من مجموعة موجودة
nums = (1, 2, 3)
char = ('a',)
new_tuple = nums + char
print(new_tuple) # (1, 2, 3, 'a')

المجموعات (Sets)

المجموعات (Sets) هي مجموعات غير مرتبة من العناصر الفريدة (لا تحتوي على تكرارات).

alpha = {'a', 'b', 'c', 'a'}
print(alpha) # { 'a', 'c', 'b' } (قد يختلف الترتيب). كما ترى، تم إزالة التكرارات والناتج غير مرتب.

# الوصول إلى العناصر في المجموعة
# لا يمكنك الوصول عن طريق الفهرس لأن المجموعات غير مرتبة. يمكنك الوصول إليها فقط عبر حلقة تكرارية.
for ele in alpha:
    print(ele)

# إضافة عناصر إلى المجموعة
alpha.add('s') # تستخدم add() لإضافة عنصر واحد فقط.
alpha.update(['a', 'x', 'z']) # تستخدم update() لإضافة عناصر متعددة. تذكر أن التكرارات تُزال.

# طول المجموعة
len(alpha) # 5

# إزالة العناصر من المجموعة
alpha.remove('a') # تحذف العنصر. إذا لم يكن موجودًا، ستُطلق خطأ.
alpha.discard('a') # تحذف العنصر. أكثر أمانًا من remove() لأنها لا تُطلق خطأ حتى لو لم يكن العنصر موجودًا.

القواميس (Dictionaries)

القواميس في بايثون هي خرائط مفتاح-قيمة (key-value maps). إنها مجموعات غير مرتبة.

user = {'id': 1, 'name': 'John wick', 'email': 'john@gmail.com'}
user['id'] # 1
user['name'] # John wick

# طول القاموس
len(user) # 3

# إضافة زوج مفتاح-قيمة جديد
user['age'] = 35

# الحصول على جميع المفاتيح
keys = user.keys() # ['id', 'name', 'email', 'age']. هذا سيعيد قائمة بالمفاتيح.

# الحصول على جميع القيم
values = user.values() # [1, 'John wick', 'john@gmail.com', 35]. هذا سيعيد قائمة بالقيم.

# حذف مفتاح
del user['age']

# مثال على قاموس متداخل (Nested Dictionary)
user = {
    'id': 1,
    'name': 'John wick',
    'cars': ['audi', 'bmw', 'tesla'],
    'projects': [
        {'id': 10, 'name': 'Project 1'},
        {'id': 11, 'name': 'Project 2'}
    ]
}

الشروط (if..else)

من المحتمل أنك تعرف بالفعل كيف تعمل عبارات if..else. لكن دعنا نرى مثالًا هنا، مع التركيز على المسافات البادئة (Indentation) التي تعتبر حاسمة في بايثون.

a = 5
b = 10

# انتبه للمسافات البادئة. المسافات البادئة مهمة جدًا في بايثون، وستُطلق بايثون خطأ إذا لم تكن صحيحة.
if a == 5:
    print('Awesome')

# العامل 'and' يكافئ '&&' في لغات أخرى
if a == 5 and b == 10:
    print('A is five and b is ten')

# عبارة if-else. تشبه معظم اللغات.
if a == 5:
    print('A is five')
elif a == 6:
    print('A is six')
elif a == 7:
    print('A is seven')
else:
    print('A is some number')

# العامل 'or' يكافئ '||' في لغات أخرى
if a < 6 or a == 10:
    print('A should be less than 6 or should be equal to ten')

# العامل 'not' يكافئ '!' في لغات أخرى
if not a == 10:
    print('A is not equal to 10')

# الاختصار لعبارة if
if a == 5: print('A is five')

# الاختصار لعبارة if-else
print('A is five') if a == 5 else print('A is not five')

الحلقات التكرارية (Loops)

توجد في بايثون نوعان رئيسيان من الحلقات التكرارية: while و for.

حلقات while

تستمر حلقة while في التنفيذ طالما كان الشرط صحيحًا.

# الحلقة التالية ستطبع الأرقام حتى 5. تذكر المسافة البادئة.
i = 0
while i <= 5:
    print(i)
    i += 1

# استخدام 'break' أو 'continue' في حلقة while
i = 0
while i <= 5:
    print(i)
    i += 1
    if i == 2:
        break # يوقف الحلقة عند i=2
# يمكنك تجربة استخدام continue هنا لتخطي التكرار الحالي.

# الجزء المثير للاهتمام: حلقات while في بايثون يمكن أن تحتوي على جزء 'else'.
# يتم تنفيذ جزء 'else' بعد اكتمال الحلقة بالكامل (أي عندما يصبح الشرط خاطئًا).
i = 10
while i <= 15:
    print(i)
    i += 1
else:
    print('Completed')
# الناتج:
# 10
# 11
# 12
# 13
# 14
# 15
# Completed

# ولكن إذا استخدمت 'break' في الحلقة، فلن يتم تنفيذ جزء 'else'.
i = 10
while i <= 15:
    print(i)
    i += 1
    if i == 13:
        break
else:
    print('Completed') # هذا السطر لن يتم تنفيذه
# الناتج:
# 10
# 11
# 12

حلقات for

في بايثون، تُستخدم حلقات for عادةً للتكرار عبر عناصر مجموعة (iterable) بدلاً من التكرار بناءً على فهرس كما في لغات أخرى.

arr = ['a', 'b', 'c', 'd', 'e']
for ele in arr: # تطبع كل عنصر في القائمة
    print(ele)

word = "python"
for char in word: # تطبع كل حرف في الكلمة
    print(char)

# يمكنك استخدام 'break' و 'continue' وجزء 'else' في حلقات for أيضًا.

# دالة range()
# تُستخدم دالة range() لإنشاء تسلسل من الأرقام.
# range(start, stop, step)
# start - اختياري، الرقم الذي يبدأ منه التسلسل (مضمن). الافتراضي هو 0.
# stop - إجباري، الرقم الذي يتوقف عنده التسلسل (غير مضمن).
# step - اختياري، مقدار الزيادة. الافتراضي هو 1.

# range(3) # يُنشئ تسلسل من 0 إلى 2
# range(1, 4) # يُنشئ تسلسل من 1 إلى 3
# range(1, 8, 2) # يُنشئ تسلسل: 1, 3, 5, 7

for ele in range(3): # تطبع من 0 إلى 2.
    print(ele)

# التكرار عبر قائمة باستخدام الفهرس (أقل شيوعًا في بايثون)
for index in range(0, len(arr)):
    print(arr[index])

# التكرار عبر قاموس
dict_example = {'name': 'John wick', 'age': 30}
# الدالة items() تعيد أزواج المفتاح والقيمة. يمكنك أيضًا استخدام keys() أو values().
for key, value in dict_example.items():
    print(key + " is " + str(value))

# دالة enumerate()
# تُعيد enumerate() مجموعة (tuple) تحتوي على الفهرس والقيمة، وتُستخدم لإضافة عداد للكائنات القابلة للتكرار.
for index, value in enumerate(arr):
    print(value + " is present at index " + str(index))

الدوال (Functions)

الدوال هي كتل من التعليمات البرمجية التي تُنفذ مهمة محددة. تُعرّف الدوال باستخدام الكلمة المفتاحية def.

def prints_hello_world():
    print('Hello world from Python')

prints_hello_world()

# عبارة 'return'
def prints_something(something):
    return something + ' from Python'

print(prints_something('Hello world'))

# إذا مررت عددًا خاطئًا من الوسائط، ستُطلق بايثون خطأ.
# print(prints_something()) # سيُطلق خطأ

# المعاملات الافتراضية (Default parameters)
def prints_something(something='Hello world'):
    print(something + ' from Python')

prints_something() # ستستخدم القيمة الافتراضية
prints_something('Custom message') # ستستخدم القيمة الممررة

# وسائط الكلمات المفتاحية (Keyword arguments)
# يمكنك تمرير الوسائط بشكل صريح باسم المعامل، مما يلغي الحاجة لترتيب الوسائط.
def movie_info(title, director_name, ratings):
    print(title + " - " + director_name + " - " + ratings)

movie_info(ratings='9/10', director_name='David Fincher', title='Fight Club')

# عدد عشوائي من الوسائط (*args)
# عندما لا تعرف عدد الوسائط التي سيتم تمريرها، يمكنك استخدام *names لجمعها في مجموعة (tuple).
def languages(*names):
    print(names) # ('Python', 'Ruby', 'JavaScript', 'Go') - هذه مجموعة
    return 'You have mentioned ' + str(len(names)) + ' languages'

print(languages('Python', 'Ruby', 'JavaScript', 'Go')) # الناتج: You have mentioned 4 languages

def languages(fav_language, *names):
    print(names) # ('Ruby', 'JavaScript', 'Go')
    return 'My favorite language is ' + fav_language + '. And Im planning to learn other ' + str(len(names)) + ' languages too'

print(languages('Python', 'Ruby', 'JavaScript', 'Go')) # الناتج: My favorite language is Python. And Im planning to learn other 3 languages too

# عدد عشوائي من وسائط الكلمات المفتاحية (**kwargs)
# هذه الأنواع من الوسائط مفيدة عندما لا تعرف نوع المعاملات التي سيتم تمريرها.
# تُجمع في قاموس (dictionary).
def user_info(**info):
    print(info) # {'id': 1, 'name': 'Srebalaji', 'fav_language': ['Python', 'Ruby']} - هذا قاموس

# تتوقع **kwargs دائمًا تمرير المعاملات بشكل صريح ككلمات مفتاحية.
user_info(id=1, name='Srebalaji', fav_language=['Python', 'Ruby'])

# الكود أدناه سيُطلق خطأ لأنه لا توجد وسائط كلمات مفتاحية.
# user_info(1, 'Srebalaji')

def user_info(id, name, **info):
    print(info) # {'fav_language': ['Python', 'Ruby'], 'twitter_handle': '@srebalaji'}

user_info(1, 'Srebalaji', fav_language=['Python', 'Ruby'], twitter_handle='@srebalaji')

الفئات (Classes)

بايثون لغة متعددة الأغراض وتدعم البرمجة كائنية التوجه (Object-Oriented Programming). من التقاليد أن يبدأ اسم الفئة بحرف كبير، لكن بايثون لا تُطلق خطأ إذا لم تلتزم بذلك.

class Animal():
    # هذا هو المُنشئ (constructor).
    # كما ترى، في كل دالة داخل الفئة، مررت 'self' كمعامل أول. المعامل الأول دائمًا ما يُتوقع أن يكون النسخة الحالية من الفئة، وهو إلزامي.
    # يمكنك تسمية هذا المتغير بأي اسم تريده، لكن 'self' هو الاصطلاح الشائع.
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(self.name + ' eats')

    def sleep(self):
        print(self.name + ' sleeps')

# إنشاء نسخة من الفئة
dog = Animal('harry')
dog.eat()
print(dog.name) # كما ترى، السمة 'name' متاحة للعامة.

# يمكن تعديلها أيضًا.
dog.name = 'Rosie'
print(dog.name) # 'Rosie'

# السمات المحمية (Protected attributes)
# يمكن الوصول إلى هذه السمات داخل الفئة وفي الفئات الفرعية فقط (اصطلاحًا).
class Person():
    def __init__(my_instance, name):
        # السمة '_name' محمية (اصطلاحًا).
        my_instance._name = name

    def reads(my_instance):
        print(my_instance._name + ' reads')

    def writes(my_object):
        print(my_object._name + ' writes')

person1 = Person('Ram')
person1.reads() # Ram reads

# لكن الجزء الأسوأ هو أن نسخة الفئة لا تزال تستطيع الوصول إليها وتغييرها :P
print(person1._name) # 'Ram'
person1._name = 'I can still change.'
print(person1._name) # I can still change.

# السمات المحمية يمكن أن تكون مفيدة أحيانًا. لنرى كيف تعمل السمات الخاصة.

# السمات الخاصة (Private attributes)
# هذه السمات لا يمكن الوصول إليها إلا داخل الفئة نفسها.
class Person():
    def __init__(self, name):
        # السمة '__name' خاصة (اصطلاحًا).
        self.__name = name

    def reads(self):
        print(self.__name + ' reads')

    def writes(self):
        print(self.__name + ' writes')

    # هذه دالة خاصة. لا يمكن الوصول إليها من خارج الفئة.
    def __some_helper_method():
        print('Some helper method.')

person1 = Person('Ram')
person1.reads() # Ram reads
# print(person1.name) # سيُطلق خطأ: 'Person' object has no attribute 'name'
# print(person1.__name) # سيُطلق خطأ: 'Person' object has no attribute '__name'

# السمات الخاصة لا يمكن الوصول إليها إلا داخل الفئة. لذا فهي آمنة. ولكن لا يزال هناك خدعة :P
# يمكن الوصول إليها باستخدام 'name mangling' (تغيير الاسم)
print(person1._Person__name) # Ram.

# يمكنك حتى تغيير القيمة بهذه الطريقة
person1._Person__name = 'Hari'
print(person1._Person__name) # Hari.

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

# الوراثة (Inheritance)
class Animal():
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('Animal eats')

    def sleep(self):
        print('Animal sleeps')

# Dog هي فئة فرعية من Animal
class Dog(Animal):
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('Dog eats') # تجاوز (override) دالة eat من الفئة الأم

dog1 = Dog('harry')
dog1.eat() # Dog eats
dog1.sleep() # Animal sleeps (تُورث من الفئة Animal)

الوحدات (Modules)

تساعدنا الوحدات (Modules) في تنظيم التعليمات البرمجية في بايثون. يمكنك تقسيم الكود إلى ملفات ومجلدات مختلفة والوصول إليها عند الحاجة.

لنعتبر الملف التالي الذي يحتوي على دالتين:

# calculations.py
def add(a, b):
    return a + b

def substract(a, b):
    return a - b

والآن، لنعتبر ملفًا آخر سنعتبره الملف الرئيسي:

# main.py
import calculations

calculations.add(5, 10) # 15
calculations.substract(10, 3) # 7

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

# يمكنك تغيير اسم الوحدة عند الاستيراد
import calculations as calc
calc.add(5, 10) # 15

# يمكنك استيراد دوال محددة تحتاجها فقط
# يمكنك الوصول إلى الدالة مباشرة دون ذكر اسم الوحدة.
from calculations import add
add(5, 10) # 15

# يمكنك أيضًا استيراد دوال متعددة
from calculations import add, multiple, divide

# أو استيراد جميع الدوال من الوحدة (لا يُنصح بها في المشاريع الكبيرة لتجنب تضارب الأسماء)
from calculations import *
add(10, 15)
multiple(4, 5)
divide(10, 3)

هذه الطرق تعمل أيضًا مع الفئات والمتغيرات.

القيم الحقيقية والكاذبة (Truthy and Falsy values)

وفقًا لوثائق بايثون، يمكن اختبار أي كائن لمعرفة ما إذا كان يعتبر Truthy (صحيحًا) أو Falsy (كاذبًا) في سياق منطقي.

القيم الحقيقية (Truthy values)

  • True
  • أي قيم رقمية غير الصفر (مثل 2)
  • القوائم غير الفارغة (مثل [1])
  • القواميس غير الفارغة (مثل {'a': 1})
  • السلاسل النصية غير الفارغة (مثل 'a')
  • المجموعات غير الفارغة (مثل {'a'})

القيم الكاذبة (Falsy values)

  • False
  • None
  • الصفر (0)
  • الصفر العشري (0.0)
  • القوائم الفارغة ([])
  • القواميس الفارغة ({})
  • المجموعات الفارغة (())
  • السلاسل النصية الفارغة ("")
  • مجال فارغ (range(0))

يمكنك تقييم أي كائن إلى قيمة منطقية باستخدام الدالة bool(any_object)، والتي ستُعيد إما True أو False.

معالجة الاستثناءات (Exception handling)

يمكن تغليف التعليمات البرمجية التي قد تُطلق استثناءات داخل عبارة try. بينما تتولى عبارة except معالجة هذا الاستثناء.

try:
    some_error_raised # هذا المتغير غير معرف وسيُطلق NameError
except:
    print('Exception handled')

كل استثناء في بايثون يرث من الفئة Exception. في المثال أدناه، سترى أن NameError هي فئة استثناء مشتقة من الفئة الرئيسية Exception.

try:
    some_error_raised
except Exception as e:
    print('Exception raised')
    print(e.__class__) #

كتلة else ستُنفذ إذا لم تُطلق التعليمات البرمجية في كتلة try أي استثناء. وهذا مفيد في العديد من المواقف.

try:
    # هذا الكود لن يطلق خطأ إذا كان 'some_variable' معرفًا
    # some_variable = 1
    # print(some_variable)
    pass # لا تفعل شيئًا، لتجنب NameError
except:
    print('Exception handled')
else:
    print('No error raised. You can resume your operation here')
# هذا الكود سيُنفذ إذا لم تُطلق أخطاء في كتلة try

كتلة finally: التعليمات البرمجية في كتلة finally ستُنفذ بغض النظر عما إذا كان الاستثناء قد أُطلق أم لا.

try:
    some_error_raised
except Exception as e:
    print('Exception raised')
else:
    print('This will execute if no error is raised in try')
finally:
    print('This code will run whether the code has error or not.')

إطلاق استثناءاتك الخاصة: يمكنك أيضًا إنشاء فئات استثناء خاصة بك ترث من فئة Exception.

try:
    raise ZeroDivisionError # فئة استثناء بايثون مدمجة
except Exception as e:
    print(e.__class__) #

التقاط استثناء محدد:

try:
    raise ZeroDivisionError # فئة استثناء بايثون مدمجة
except TypeError as e:
    print('Only type error exception is captured')
except ZeroDivisionError as e:
    print('Only zero division exception is captured')
except Exception as e:
    print('Other exceptions')

الخلاصة التقنية

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

اترك تعليقاً

لن يتم نشر عنوان بريدك الإلكتروني. الحقول الإلزامية مشار إليها بـ *