دليل عملي لتعلّم بايثون للمبتدئين: أمثلة برمجية تشرح الأساسيات خطوة بخطوة

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

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

ما الذي ستتعلمه في هذا الدليل؟

• كيفية تعريف المتغيرات في Python.
• كتابة برنامج Hello, World!.
• أنواع البيانات الأساسية والهياكل المدمجة.
• المعاملات الشرطية والحلقات التكرارية.
• كتابة الدوال واستخدام return.
• مفهوم الاستدعاء الذاتي Recursion.
• التعامل مع الأخطاء والاستثناءات.
• أساسيات البرمجة الكائنية OOP.
• قراءة الملفات وكتابتها.
• أوامر الاستيراد import وفهم التجميع المختصر للقوائم والقواميس.

ملاحظة مهمة: عند رؤية صيغة مثل <var> أو <value>، فهذا يعني أن هذا الجزء يُستبدل بقيمة حقيقية عند كتابة الكود.

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

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

<var_name> = <value>

أمثلة:

age = 56
name = "Nora"
color = "Blue"
grades = [67, 100, 87, 56]

إذا كان اسم المتغير يتكون من أكثر من كلمة، فمن الأفضل الفصل بينها باستخدام الشرطة السفلية _ وفق توصيات الدليل الإرشادي PEP 8:

my_list = [1, 2, 3, 4, 5]

كتابة أول برنامج: Hello, World!

أبسط برنامج يمكن أن تبدأ به في Python يعتمد على الدالة print():

print("Hello, World!")

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

Hello, World!

هذا المثال تقليد معروف في عالم البرمجة، ويُستخدم عادةً لتجربة البيئة البرمجية والتأكد من أن كل شيء يعمل كما ينبغي.

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

الأعداد الصحيحة int

تمثل الأعداد التي لا تحتوي على جزء عشري:

type(1)
type(15)
type(0)
type(-46)

الأعداد العشرية float

تتضمن فاصلة عشرية، مثل:

type(4.5)
type(5.8)
type(4.0)
type(-23.5)

الأعداد المركبة complex

تتكون من جزء حقيقي وآخر تخيلي يُكتب باستخدام j:

complex(4, 5)
complex(6, 8)
complex(0, 4)

السلاسل النصية str

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

"Hello, World!"
'Hello, World!'
"45678"
"my_email@email.com"

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

الفهارس داخل السلاسل النصية

لكل حرف داخل السلسلة النصية موضع يسمى فهرساً index يبدأ من 0:

my_string = "Hello"
print(my_string[0])
print(my_string[1])
print(my_string[-1])

القيمة -1 تُستخدم كثيراً للوصول إلى آخر حرف.

تقطيع السلاسل النصية Slicing

للحصول على جزء من النص نستخدم الصيغة:

<string_variable>[start:stop:step]

مثال:

freecodecamp = "freeCodeCamp"
print(freecodecamp[2:8])
print(freecodecamp[:8])
print(freecodecamp[:: -1])

آخر سطر يعكس النص بالكامل.

السلاسل المنسقة f-strings

تتيح لك دمج القيم داخل النصوص بشكل أنيق وسريع:

first_name = "Nora"
favorite_language = "Python"
print(f"Hi, I'm {first_name}. I'm learning {favorite_language}.")

كما يمكن تضمين تعبيرات ودوال داخل الأقواس المعقوفة {}.

أشهر دوال النصوص

توفر Python مجموعة كبيرة من الدوال الجاهزة للتعامل مع النصوص:

freecodecamp = "freeCodeCamp"
print(freecodecamp.capitalize())
print(freecodecamp.count("C"))
print(freecodecamp.find("e"))
print(freecodecamp.lower())
print(freecodecamp.upper())
print(freecodecamp.replace("e", "a"))
print(freecodecamp.split("C"))

هذه الدوال تعيد نسخة جديدة من السلسلة النصية، لأن النصوص في Python غير قابلة للتعديل المباشر immutable.

القيم المنطقية bool

القيمتان المنطقيتان في بايثون هما True وFalse، ويجب كتابتهما بحرف كبير في البداية:

type(True)
type(False)

الهياكل المدمجة في بايثون

القوائم list

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

[1, 2, 3, 4, 5]
["a", "b", "c", "d"]
[1, "Emily", 3.4]

إسناد قائمة إلى متغير:

my_list = [1, 2, 3, 4, 5]

القوائم المتداخلة

my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[0])
print(my_list[1])

تُستخدم كثيراً لتمثيل الجداول أو الشبكات الثنائية الأبعاد.

طول القائمة

my_list = [1, 2, 3, 4]
print(len(my_list))

تعديل وإضافة وحذف العناصر

letters = ["a", "b", "c", "d"]
letters[0] = "z"

my_list = [1, 2, 3, 4]
my_list.append(5)
my_list.remove(3)

تقطيع القوائم

my_list = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
print(my_list[2:6:2])
print(my_list[::-1])

أهم دوال القوائم

my_list = [1, 2, 3, 3, 4]
my_list.append(5)
my_list.extend([6, 7, 8])
my_list.insert(2, 15)
my_list.remove(2)
my_list.pop()
my_list.index(6)
my_list.count(2)
my_list.sort()
my_list.reverse()
my_list.clear()

الصفوف tuple

تشبه القوائم لكنها غير قابلة للتعديل بعد الإنشاء:

my_tuple = (1, 2, 3, 4, 5)

يمكن الوصول إلى عناصرها وفحص طولها وتقطيعها بالطريقة نفسها تقريباً:

my_tuple = (1, 2, 3, 4)
print(my_tuple[0])
print(my_tuple[-1])
print(len(my_tuple))

ومن دوالها الأساسية:

my_tuple = (4, 4, 5, 6, 6, 7, 8)
print(my_tuple.count(6))
print(my_tuple.index(7))

الإسناد المتعدد

تتيح لك بايثون إسناد أكثر من قيمة في سطر واحد:

a, b = 1, 2
a, b = b, a

القواميس dict

القاموس يخزن البيانات على شكل أزواج key:value:

my_dict = {"a": 1, "b": 2, "c": 3}

يمكن أن تكون المفاتيح نصوصاً أو أرقاماً أو صفوفاً، بشرط أن تكون غير قابلة للتغيير.

الوصول إلى القيم وتعديلها

my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
print(my_dict["a"])
my_dict["b"] = 6
my_dict["e"] = 5
del my_dict["c"]

أهم دوال القواميس

my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}
print(my_dict.get("c"))
print(my_dict.items())
print(my_dict.keys())
print(my_dict.values())
my_dict.pop("d")
my_dict.update({"e": 5})
my_dict.clear()

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

المعاملات الحسابية

تشمل العمليات الأساسية مثل + و- و* و/ و// و% و**.

print(5 + 6)
print(10 - 3)
print(5 * 6)
print(25 / 5)
print(8 // 2)
print(17 % 8)
print(5 ** 2)

انتبه إلى أن القسمة باستخدام / تعيد عادةً قيمة من النوع float حتى لو كان الناتج عدداً صحيحاً ظاهرياً.

معاملات المقارنة

تُستخدم للمقارنة بين القيم، وتعيد True أو False:

• >
• >=
• <
• <=
• ==
• !=

print(10 > 8)
print(8 == 8)
print(56 != 78)

المعاملات المنطقية

تشمل and وor وnot:

print(True and False)
print(True or False)
print(not True)

معاملات الإسناد

x = 3
x += 15
x -= 2
x *= 2
x %= 5
x /= 1
x //= 2
x **= 5

معاملات العضوية

باستخدام in وnot in يمكنك فحص ما إذا كان عنصر ما موجوداً داخل تسلسل:

print(5 in [1, 2, 3, 4, 5])
print("H" in "Hello")
print("c" not in {"a": 1, "b": 2})

الجمل الشرطية في بايثون

جملة if

x = 15
if x > 9:
    print("Hello!")

جملة if/else

x = 5
if x > 9:
    print("Hello!")
else:
    print("Bye!")

جملة if/elif/else

x = 13
if x < 9:
    print("Hello!")
elif x < 15:
    print("It's great to see you")
else:
    print("Bye!")

في Python تُعد المسافات البادئة indentation جزءاً أساسياً من بنية الكود، وليست مجرد تنسيق شكلي.

الحلقات التكرارية في بايثون

حلقة for

تُستخدم لتكرار تنفيذ كود على عناصر تسلسل أو على ناتج range():

for i in range(5):
    print(i)

مع وسيطين أو ثلاثة:

for i in range(2, 10):
    print(i)

for i in range(3, 16, 2):
    print(i)

التكرار على النصوص والقوائم والقواميس

message = "Hello, World!"
for char in message:
    print(char)

my_list = [2, 3, 4, 5]
for num in my_list:
    print(num)

my_dict = {"a": 1, "b": 2, "c": 3}
for key in my_dict:
    print(key)

for value in my_dict.values():
    print(value)

for key, value in my_dict.items():
    print(key, value)

الأوامر break وcontinue

my_list = [1, 2, 3, 4, 5]
for elem in my_list:
    if elem % 2 == 0:
        print("Even:", elem)
        break
    else:
        print("Odd:", elem)

my_list = [1, 2, 3, 4, 5]
for elem in my_list:
    if elem % 2 == 0:
        continue
    print("Odd:", elem)

الدالتان zip() وenumerate()

my_list1 = [1, 2, 3, 4]
my_list2 = [5, 6, 7, 8]
for elem1, elem2 in zip(my_list1, my_list2):
    print(elem1, elem2)

my_list = [5, 6, 7, 8]
for i, elem in enumerate(my_list):
    print(i, elem)

جملة else مع for

my_list = [1, 2, 3, 4, 5]
for elem in my_list:
    if elem > 6:
        print("Found")
        break
else:
    print("Not Found")

حلقة while

تستمر طالما أن الشرط يساوي True:

x = 6
while x < 15:
    print(x)
    x += 1

من المهم تحديث المتغيرات داخل الشرط لتجنب الحلقة اللانهائية infinite loop.

x = 5
while x > 2:
    print(x)

الكود السابق سيستمر بلا توقف ما لم تُحدَّث قيمة x.

الحلقات المتداخلة

for i in range(3):
    for j in range(2):
        print(i, j)

num_rows = 5
for i in range(5):
    for num_cols in range(num_rows - i):
        print("*", end="")
    print()

الدوال في بايثون

الدوال تساعدك على تنظيم الكود وإعادة استخدامه بسهولة.

دالة بدون معاملات

def print_pattern():
    size = 4
    for i in range(size):
        print("*" * size)

دالة بمعامل واحد

def welcome_student(name):
    print(f"Hi, {name}! Welcome to class.")

دالة بأكثر من معامل

def print_sum(a, b):
    print(a + b)

إرجاع قيمة باستخدام return

def get_rectangle_area(length, width):
    return length * width

area = get_rectangle_area(4, 5)
print(area)

def get_first_even(seq):
    for elem in seq:
        if elem % 2 == 0:
            return elem
    return None

المعاملات الافتراضية

def print_product(a, b=5):
    print(a * b)

print_product(4)
print_product(3, 4)

الاستدعاء الذاتي في بايثون Recursion

الدالة الذاتية هي التي تستدعي نفسها، ويجب أن تحتوي على حالة أساسية توقف التكرار:

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

def fibonacci(n):
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

def find_power(a, b):
    if b == 0:
        return 1
    else:
        return a * find_power(a, b - 1)

معالجة الاستثناءات في بايثون

الاستثناء exception هو خطأ يحدث أثناء تنفيذ البرنامج. من أشهر الأنواع:

• ZeroDivisionError عند القسمة على صفر.
• IndexError عند استخدام فهرس غير صالح.
• KeyError عند طلب مفتاح غير موجود في القاموس.
• NameError عند استخدام متغير غير معرّف.
• RecursionError عند تجاوز عمق الاستدعاء الذاتي.

استخدام try وexcept

index = int(input("Enter the index: "))
try:
    my_list = [1, 2, 3, 4]
    print(my_list[index])
except:
    print("Please enter a valid index.")

التعامل مع نوع محدد من الأخطاء

try:
    my_list = [1, 2, 3, 4]
    print(my_list[15])
except IndexError:
    print("Please enter a valid index.")

التقاط كائن الخطأ

try:
    a = 5
    b = 0
    print(a / b)
except ZeroDivisionError as err:
    print("Please enter valid values.", err)

استخدام else وfinally

try:
    a = 5
    b = 4
    division = a / b
    print(division)
except ZeroDivisionError as err:
    print("Please enter valid values.", err)
else:
    print("Both values were valid.")
finally:
    print("Finally!")

البرمجة الكائنية في بايثون OOP

تعتمد البرمجة الكائنية على تعريف أصناف classes تُستخدم كقوالب لإنشاء كائنات objects.

تعريف صنف بسيط

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

إنشاء كائن والوصول إلى خصائصه

my_dog = Dog("Nora", 10)
print(my_dog.name)
print(my_dog.age)

تعديل الخصائص وحذفها

my_dog.name = "Norita"
del my_dog.name

خصائص الصنف Class Attributes

class Dog:
    kingdom = "Animalia"

    def __init__(self, name, age):
        self.name = name
        self.age = age

print(Dog.kingdom)

تعريف دوال داخل الصنف

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"woof-woof. I'm {self.name}")

my_dog = Dog("Nora", 10)
my_dog.bark()

الخصائص property وعمليات getter وsetter

class Dog:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        self._name = new_name

    @name.deleter
    def name(self):
        del self._name

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

قراءة ملف

with open("famous_quotes.txt", "r") as file:
    for line in file:
        print(line)

الكتابة إلى ملف

words = ["Amazing", "Green", "Python", "Code"]
with open("famous_quotes.txt", "w") as file:
    for word in words:
        file.write(word + "\n")

الإلحاق بملف موجود

words = ["Amazing", "Green", "Python", "Code"]
with open("famous_quotes.txt", "a") as file:
    for word in words:
        file.write(word + "\n")

حذف ملف

import os

if os.path.exists("famous_quotes.txt"):
    os.remove("famous_quotes.txt")
else:
    print("This file doesn't exist")

جمل الاستيراد في بايثون

كلما كبر مشروعك ستحتاج إلى تقسيمه إلى ملفات متعددة. وهنا تظهر أهمية أوامر import.

أشكال شائعة للاستيراد

import math
print(math.sqrt(25))

import math as m
print(m.sqrt(25))

from math import sqrt
print(sqrt(25))

from math import sqrt as square_root
print(square_root(25))

from math import *
print(sqrt(25))

يُفضَّل غالباً تجنب الاستيراد الشامل باستخدام from module import * لأنه يقلل وضوح الكود.

التجميع المختصر للقوائم والقواميس

تجميع القوائم List Comprehension

[i for i in range(4, 15)]
[chr(i) for i in range(67, 80)]
[i ** 3 for i in range(2, 5)]
[k for k in range(3, 35) if k % 2 == 0]

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

مقارنة مع Generator Expressions

تجميع القوائم ينشئ القائمة كاملة في الذاكرة، بينما التعبير المولد generator expression ينتج العناصر عند الطلب، وهو أوفر في استهلاك الذاكرة في بعض الحالات.

import sys
print(sys.getsizeof([i for i in range(500)]))
print(sys.getsizeof((i for i in range(500))))

تجميع القواميس Dictionary Comprehension

{num: num ** 3 for num in range(3, 15)}

grades = {"Nora": 78, "Gino": 100, "Talina": 56, "Elizabeth": 45, "Lulu": 67}
approved_students = {student: grade for (student, grade) in grades.items() if grade >= 60}
print(approved_students)

نصائح عملية لتعلّم بايثون بسرعة

• طبّق كل مفهوم مباشرة بعد قراءته.
• ابدأ بمشروعات صغيرة مثل آلة حاسبة أو برنامج إدارة مهام.
• راجع الأخطاء البرمجية بنفسك قبل البحث عن الحل.
• التزم بأسلوب كتابة واضح ومتسق مثل إرشادات PEP 8.
• لا تحفظ الأمثلة فقط، بل حاول تعديلها وتوسيعها.

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

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