الفرق بين المكتبات المدمجة (Standard Library) والمكتبات الخارجية
عند استخدام بايثون، ستتعامل مع نوعين من المكتبات: المدمجة (أو القياسية) والخارجية. هذا الفرق جوهري، خصوصًا لمن يريد كتابة كود بسيط وقابل للتنفيذ فورًا دون الدخول في مشاكل التثبيت أو الاعتماديات.
1. المكتبات المدمجة (Standard Library):
هي مجموعة ضخمة من الوحدات (modules) التي تأتي مثبتة مسبقًا مع أي نسخة من لغة بايثون. لا تحتاج إلى أي أمر تثبيت عبر pip أو أي مدير حزم. يمكنك استدعاؤها مباشرة باستخدام import. هذه المكتبات تغطي كل شيء تقريبًا: التعامل مع الملفات، الوقت، العمليات الرياضية، الشبكات، التعامل مع JSON، الضغط، إنشاء الخيوط، والتعامل مع النظام وغيرها.
مثال:
import os
print(os.getcwd())
لا حاجة لتثبيت مكتبة os، لأنها جزء من بايثون نفسه.
2. المكتبات الخارجية (Third-party Libraries):
هي مكتبات يكتبها المجتمع أو جهات خارجية، ولا تأتي مثبتة مع بايثون. تحتاج إلى تثبيتها يدويًا باستخدام pip install. غالبًا ما تكون هذه المكتبات متقدمة جدًا أو تقدم وظائف متخصصة لا تغطيها المكتبات القياسية.
مثال:
import requests
مكتبة requests شهيرة جدًا للتعامل مع HTTP، لكنها ليست مدمجة في بايثون، ويجب تثبيتها.
الفرق العملي:
المكتبات المدمجة تتيح لك البدء بسرعة دون أي تحضيرات، وتضمن أن الكود سيعمل على أي نظام فيه بايثون. أما المكتبات الخارجية فهي ضرورية في المشاريع المتقدمة، لكنها تزيد من تعقيد البيئة وتجعل من الصعب تشغيل السكربت على جهاز جديد بدون إعداد مسبق.
باختصار:
-
المكتبات المدمجة = جاهزة دائمًا، مناسبة للمهام العامة.
-
المكتبات الخارجية = تحتاج إلى تثبيت، لكنها ضرورية للمهام المتقدمة أو المختصة.
لماذا تعتبر مكتبات بايثون المدمجة قوة حقيقية للغة
واحدة من أهم الأسباب التي جعلت لغة بايثون تنتشر بهذا الشكل الواسع هي مكتبتها القياسية الضخمة. هذه المكتبات المدمجة تعني أنك، كمبرمج، لا تحتاج إلى البدء من الصفر في كل مرة، ولا تحتاج إلى الاتصال بالإنترنت أو تثبيت مكتبات خارجية لتنفيذ أغلب المهام اليومية.
1. تغطي كل الجوانب الأساسية:
من التعامل مع الملفات، مرورًا بالشبكات، وانتهاءً بالتحكم في العمليات ونظام التشغيل – مكتبات بايثون المدمجة توفر حلولًا جاهزة وسهلة لهذه الأمور. بدون الحاجة لتثبيت أو إعداد إضافي.
2. مستقرة ومدعومة رسميًا:
المكتبات القياسية يتم اختبارها وصيانتها وتوثيقها من قبل مطوري بايثون أنفسهم. وهذا يعني أنها موثوقة، ومكتوبة بأسلوب متوافق تمامًا مع اللغة. على عكس بعض المكتبات الخارجية التي قد تكون غير محدثة أو مكتوبة بجودة ضعيفة.
3. تقلل من الاعتماديات (Dependencies):
عند استخدام المكتبات المدمجة، فأنت تقلل من عدد الأشياء التي قد تتسبب في تعطل المشروع لاحقًا. لا داعي للقلق من أن المكتبة الفلانية لم تعد مدعومة أو أن الإصدار الحالي غير متوافق.
4. تعمل في أي بيئة يوجد بها بايثون:
إذا كتبت سكربت يستخدم فقط المكتبات القياسية، فسيعمل في أي مكان فيه بايثون دون إعداد مسبق. وهذا مثالي للتطبيقات الصغيرة، الأدوات النصية، والمهام التلقائية (automation).
5. تُعلِّمك الأساسيات بعمق:
عندما تستخدم مكتبات بايثون المدمجة، فإنك تتعامل مع مفاهيم البرمجة من الجذور، وليس من خلال واجهات جاهزة تخفي التعقيد. وهذا مهم جدًا خصوصًا للمبتدئين أو من يريدون فهم طريقة عمل الأمور فعلًا.
مكتبة os للتعامل مع نظام التشغيل
مكتبة os هي واحدة من أقدم وأقوى المكتبات المدمجة في بايثون، وتُستخدم للتفاعل مع نظام التشغيل بشكل مباشر. سواء كنت تريد قراءة محتوى مجلد، أو إنشاء ملف، أو حذف مجلد، أو حتى معرفة معلومات عن النظام، فإن os توفر لك الأدوات اللازمة لذلك.
من أبرز استخداماتها:
1. قراءة المجلدات والملفات:
import os
files = os.listdir('.')
print(files)
يعرض جميع الملفات والمجلدات الموجودة في المسار الحالي.
2. إنشاء مجلد جديد:
os.mkdir('new_folder')
3. حذف مجلد:
os.rmdir('new_folder')
4. معرفة المسار الحالي:
print(os.getcwd())
5. تغيير المسار الحالي:
os.chdir('/path/to/another/folder')
6. التحقق من وجود ملف أو مجلد:
os.path.exists('some_file.txt')
7. التعامل مع المسارات بشكل ديناميكي:
path = os.path.join('folder', 'file.txt')
print(path)
هذه المكتبة تغنيك في أغلب الحالات عن التعامل المباشر مع أوامر النظام، وتوفر واجهة برمجية مستقرة وآمنة لتشغيل العمليات المتعلقة بالملفات والمجلدات والمسارات.
مكتبة sys للتعامل مع مكونات البيئة وتوجيه التنفيذ
مكتبة sys تتيح لك الوصول إلى معلومات وخصائص خاصة بمفسر بايثون والبيئة التي يعمل فيها السكربت. تُستخدم هذه المكتبة في مواقف عديدة مثل التعامل مع سطر الأوامر، إدارة المسارات، الخروج من البرنامج، أو حتى إعادة توجيه المخرجات.
أهم استخدامات sys:
1. قراءة وسائط سطر الأوامر (Command-line arguments):
import sys
print(sys.argv)
القائمة sys.argv تحتوي على جميع القيم التي أُعطيت للبرنامج عند تشغيله، حيث يكون العنصر الأول دائمًا هو اسم الملف نفسه.
2. إنهاء البرنامج يدويًا:
sys.exit()
يمكن أيضًا تمرير كود خروج معين:
sys.exit(1) # يدل على وجود خطأ
3. طباعة معلومات عن إصدار بايثون:
print(sys.version)
4. تعديل أو استعراض مسارات الاستيراد (import paths):
print(sys.path)
sys.path.append('/my/custom/modules')
هذا مفيد إذا كنت تريد أن تسمح للبايثون بتحميل ملفات من مجلدات غير تقليدية.
5. إعادة توجيه الإخراج أو التعامل مع stdout / stderr:
sys.stdout.write("Hello\n")
sys.stderr.write("حدث خطأ\n")
مكتبة sys ضرورية لأي سكربت يحتاج إلى التحكم الدقيق في طريقة التشغيل، أو يريد التفاعل مع البيئة المحيطة به بشكل مباشر ومرن.
مكتبة datetime للتعامل مع الوقت والتواريخ
مكتبة datetime تُعتبر الأداة الأساسية في بايثون للتعامل مع التواريخ، الأوقات، والفروقات الزمنية. بدلًا من استخدام التعامل اليدوي مع الوقت كسلاسل نصية، توفر هذه المكتبة كائنات مرنة وقوية لتمثيل الوقت بدقة، وإجراء العمليات الحسابية عليه.
أهم استخدامات datetime:
1. الحصول على التاريخ والوقت الحالي:
from datetime import datetime
now = datetime.now()
print(now)
2. إنشاء كائن تاريخ/وقت مخصص:
dt = datetime(2025, 7, 1, 15, 30)
print(dt)
3. استخراج أجزاء من التاريخ:
print(now.year)
print(now.month)
print(now.day)
print(now.hour)
print(now.minute)
4. تنسيق التاريخ إلى نص (string formatting):
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)
5. تحويل نص إلى تاريخ:
date_str = "2025-07-01 15:30:00"
parsed = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(parsed)
6. حساب الفرق بين تاريخين:
from datetime import timedelta
tomorrow = now + timedelta(days=1)
print(tomorrow)
delta = tomorrow - now
print(delta.days)
7. الحصول على التاريخ فقط بدون الوقت:
print(now.date())
8. استخدام date و time بشكل منفصل:
from datetime import date, time
d = date.today()
t = time(14, 45)
print(d, t)
مكتبة datetime تغنيك عن أي مكتبة خارجية لمعالجة الوقت والتاريخ، وتدعم احتياجات التعامل مع التواريخ من أبسط العمليات إلى الحسابات الزمنية المعقدة.
مكتبة math لتنفيذ العمليات الرياضية المتقدمة
مكتبة math مخصصة لتوفير دوال رياضية دقيقة وعالية الأداء، وهي جزء من مكتبات بايثون المدمجة. عند الحاجة إلى إجراء عمليات حسابية تتجاوز الجمع والطرح، مثل الجذور، اللوغاريتمات، الدوال المثلثية، والثوابت الرياضية، فإن math هي الخيار المناسب.
أهم استخدامات مكتبة math:
1. العمليات الأساسية المتقدمة:
import math
print(math.sqrt(25)) # الجذر التربيعي
print(math.pow(2, 3)) # القوة: 2^3
print(math.factorial(5)) # مضروب 5
2. الثوابت الرياضية:
print(math.pi) # قيمة π
print(math.e) # قيمة e (اللوغاريتم الطبيعي)
3. الدوال المثلثية:
print(math.sin(math.pi / 2)) # sin(90°)
print(math.cos(0)) # cos(0°)
print(math.tan(math.pi / 4)) # tan(45°)
4. التحويل بين الدرجات والراديان:
print(math.radians(180)) # من درجات إلى راديان
print(math.degrees(math.pi)) # من راديان إلى درجات
5. الدوال اللوغاريتمية والأسية:
print(math.log(100, 10)) # log base 10
print(math.log10(1000)) # log10 مباشرة
print(math.exp(2)) # e^2
6. التقريب والتحكم في القيم:
print(math.ceil(4.2)) # التقريب للأعلى → 5
print(math.floor(4.8)) # التقريب للأسفل → 4
print(math.trunc(4.9)) # إزالة الكسور → 4
7. القيمة المطلقة والجذر التربيعي:
print(math.fabs(-7.5)) # القيمة المطلقة
print(math.isqrt(10)) # الجذر التربيعي الصحيح
مكتبة math تقدم دوال رياضية دقيقة وسريعة الأداء دون الحاجة لأي مكتبة خارجية، وهي ضرورية لكل من يعمل في البرمجة العلمية، الإحصائية، أو أي برنامج يتطلب حسابات رياضية دقيقة.
مكتبة random لتوليد أرقام عشوائية
مكتبة random تتيح لك توليد أرقام عشوائية، اختيار عناصر من القوائم بشكل عشوائي، خلط البيانات، وتوليد توزيعات احتمالية. وهي مثالية للاستخدام في الألعاب، المحاكاة، أو أي برنامج يحتاج إلى درجة من العشوائية.
أهم استخدامات مكتبة random:
1. توليد عدد عشوائي بين رقمين (صحيح):
import random
print(random.randint(1, 10)) # رقم بين 1 و 10 شامل
2. توليد عدد عشري عشوائي بين 0 و 1:
print(random.random()) # قيمة بين 0.0 و 1.0
3. توليد عدد عشري عشوائي بين قيمتين:
print(random.uniform(5, 10)) # قيمة بين 5 و 10 (عشرية)
4. اختيار عنصر عشوائي من قائمة:
items = ['apple', 'banana', 'cherry']
print(random.choice(items))
5. اختيار عدة عناصر عشوائية بدون تكرار:
print(random.sample(items, 2)) # عنصران مختلفان
6. خلط عناصر قائمة:
random.shuffle(items)
print(items)
7. استخدام التوزيعات الاحتمالية:
print(random.gauss(0, 1)) # التوزيع الطبيعي
print(random.expovariate(1)) # التوزيع الأسي
8. توليد رقم عشوائي ثابت (لأغراض الاختبار):
random.seed(42)
print(random.randint(1, 10))
مكتبة random تُستخدم كثيرًا في بناء الألعاب، خوارزميات الذكاء الاصطناعي البسيطة، نماذج الإحصاء، والاختبارات، وتعتبر أداة جاهزة ومتكاملة لتطبيق العشوائية دون الحاجة إلى أي مكتبة إضافية.
مكتبة json للتعامل مع ملفات وبيانات JSON
مكتبة json تُستخدم لتحويل البيانات بين تنسيق JSON وسلاسل بايثون (string)، أو العكس. وهي من أهم المكتبات للتعامل مع واجهات برمجة التطبيقات (APIs)، أو تخزين البيانات بطريقة خفيفة ومنظمة.
JSON هو تنسيق نصي عالمي لتبادل البيانات، يشبه القواميس والقوائم في بايثون، مما يجعل التحويل بينهما سهلًا جدًا باستخدام هذه المكتبة.
أهم استخدامات مكتبة json:
1. تحويل قاموس بايثون إلى JSON:
import json
data = {'name': 'Ali', 'age': 30}
json_str = json.dumps(data)
print(json_str)
2. تحويل سلسلة JSON إلى كائن بايثون:
json_input = '{"name": "Ali", "age": 30}'
parsed = json.loads(json_input)
print(parsed['name'])
3. حفظ البيانات بصيغة JSON في ملف:
with open('data.json', 'w') as f:
json.dump(data, f)
4. قراءة بيانات JSON من ملف:
with open('data.json', 'r') as f:
loaded = json.load(f)
print(loaded)
5. التحكم في تنسيق المخرجات:
print(json.dumps(data, indent=4, sort_keys=True))
6. التعامل مع القوائم داخل JSON:
json_list = '[1, 2, 3, 4]'
parsed_list = json.loads(json_list)
print(parsed_list[0])
مكتبة json تضمن لك توافقًا سهلًا وسريعًا مع أي نظام أو خدمة خارجية تعتمد على هذا التنسيق الشائع، وتوفر لك وظائف جاهزة للقراءة والكتابة دون الحاجة إلى أي مكتبة إضافية.
مكتبة re للبحث باستخدام التعبيرات النمطية Regular Expressions
مكتبة re تتيح لك استخدام التعبيرات النمطية (Regular Expressions) في بايثون، وهي تقنية قوية للبحث داخل النصوص، التحقق من الصيغ، استخراج الأنماط، واستبدال أو تعديل البيانات النصية بناءً على قواعد محددة.
التعبيرات النمطية تُستخدم بكثافة في تحليل النصوص، معالجة البيانات، وتنظيف المدخلات في التطبيقات البرمجية.
أهم استخدامات مكتبة re:
1. البحث عن تطابق في نص:
import re
text = "My email is [email protected]"
match = re.search(r'\S+@\S+\.\S+', text)
if match:
print(match.group()) # يعرض البريد الإلكتروني
2. استخراج جميع التطابقات:
text = "Phones: 123-456, 789-101"
phones = re.findall(r'\d{3}-\d{3}', text)
print(phones)
3. التحقق من صحة صيغة معينة:
email = "[email protected]"
is_valid = re.fullmatch(r'\w+@\w+\.\w+', email)
print(bool(is_valid)) # True إذا كانت الصيغة صحيحة
4. تقسيم النص باستخدام نمط معين:
line = "name;age;email"
parts = re.split(r';', line)
print(parts)
5. استبدال جزء معين داخل النص:
text = "The price is 100 dollars"
new_text = re.sub(r'\d+', 'XXX', text)
print(new_text)
6. استخدام المجموعات في الاستخراج:
text = "User: John, Age: 28"
match = re.search(r'User: (\w+), Age: (\d+)', text)
if match:
print(match.group(1)) # John
print(match.group(2)) # 28
مكتبة re تُعد أداة لا غنى عنها لأي مبرمج يتعامل مع النصوص، خصوصًا عند الحاجة إلى استخراج أو التحقق من أنماط معينة داخل البيانات النصية بشكل دقيق وسريع.
مكتبة subprocess لتشغيل أوامر النظام والتحكم بها
مكتبة subprocess تتيح لك تنفيذ أوامر نظام التشغيل من داخل سكربت بايثون، والتفاعل مع مخرجاتها مباشرة. تُستخدم هذه المكتبة عندما تحتاج إلى تشغيل برامج أو سكربتات خارجية، أو تنفيذ أوامر shell، وجمع النتائج أو التحكم في التدفق بناءً عليها.
على عكس مكتبة os التي توفر بعض الوظائف البسيطة للتعامل مع النظام، subprocess توفر تحكمًا كاملًا في تنفيذ العمليات الفرعية ومخرجاتها.
أهم استخدامات مكتبة subprocess:
1. تنفيذ أمر نظام بسيط وجلب المخرجات:
import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)
2. تنفيذ أمر والتعامل مع رمز الخروج:
proc = subprocess.run(['python', '--version'])
print(proc.returncode) # 0 إذا نجح
3. تنفيذ أمر كـ string (مع تفعيل shell):
subprocess.run("echo Hello World", shell=True)
4. التقاط الأخطاء ومخرجات stderr:
result = subprocess.run(['ls', 'nonexistent_file'], capture_output=True, text=True)
print(result.stderr)
5. تمرير مدخلات للأمر (stdin):
proc = subprocess.run(['cat'], input='Hello\nWorld', text=True, capture_output=True)
print(proc.stdout)
6. تنفيذ أمر والحصول على المخرجات كسلسلة مباشرة:
output = subprocess.check_output(['date'], text=True)
print(output)
7. التعامل مع الأخطاء تلقائيًا:
try:
subprocess.check_call(['false']) # أمر يفشل دائمًا
except subprocess.CalledProcessError:
print("الأمر فشل")
مكتبة subprocess مهمة لكل من يريد تنفيذ أوامر النظام بطريقة آمنة، دقيقة، وقابلة للتحكم، وتُستخدم كثيرًا في أدوات التشغيل التلقائي، إدارة السيرفرات، أو التفاعل مع أدوات خارجية من داخل كود بايثون.
مكتبة itertools للتعامل مع التكرار وتوليد التركيبات بكفاءة
مكتبة itertools تقدم مجموعة من الدوال التي تعمل على الكائنات القابلة للتكرار (iterables) مثل القوائم، التكرارات اللانهائية، أو السلاسل المعقدة من القيم. تُعتبر هذه المكتبة أداة قوية لتوليد تراكيب بيانات بطريقة مرنة وفعالة في الذاكرة، خاصة في الحلقات أو عند تنفيذ عمليات حسابية أو منطقية متكررة.
أهم استخدامات مكتبة itertools:
1. توليد التوافيق (combinations):
import itertools
items = ['a', 'b', 'c']
for combo in itertools.combinations(items, 2):
print(combo)
يعرض جميع التوافيق الممكنة بطول 2.
2. توليد التباديل (permutations):
for perm in itertools.permutations(items, 2):
print(perm)
يعرض كل التباديل الممكنة بطول 2 (الترتيب مهم).
3. التكرار غير المحدود لقيمة معينة:
count = 0
for i in itertools.repeat('X', 3):
print(i)
4. التكرار اللانهائي مع العد (عليك إيقافه يدويًا):
for i in itertools.count(start=10, step=2):
if i > 20:
break
print(i)
5. السلسلة بين أكثر من قائمة أو كائن:
a = [1, 2]
b = [3, 4]
for x in itertools.chain(a, b):
print(x)
6. التجميع بناءً على شرط معين:
data = [1, 1, 2, 2, 3, 3]
for key, group in itertools.groupby(data):
print(key, list(group))
7. التكرار على عناصر متعددة بالتوازي (مثل zip):
for x in itertools.product([1, 2], ['a', 'b']):
print(x)
مكتبة itertools توفّر أدوات قوية وعالية الكفاءة لمعالجة البيانات التكرارية، وتُستخدم بكثرة في البرمجة الوظيفية، والخوارزميات، والحلقات المعقدة التي تتطلب أداءً عاليًا دون استهلاك زائد للذاكرة.
مكتبة collections لتوفير هياكل بيانات متقدمة
مكتبة collections تقدم بدائل محسّنة ومتخصصة للهياكل التقليدية مثل القوائم والقواميس والمجموعات. توفر هذه المكتبة كائنات أكثر كفاءة وسهولة في الاستخدام للعديد من السيناريوهات، خاصة عندما تحتاج إلى التحكم المتقدم في تخزين البيانات أو ترتيبها أو عدّها.
أهم استخدامات مكتبة collections:
1. Counter: لحساب تكرار العناصر
from collections import Counter
data = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
counter = Counter(data)
print(counter)
print(counter['apple']) # عدد مرات ظهور 'apple'
2. defaultdict: قاموس بقيمة افتراضية
from collections import defaultdict
d = defaultdict(int)
d['a'] += 1
d['b'] += 3
print(d)
يمنع ظهور خطأ KeyError عند الوصول لمفتاح غير موجود.
3. namedtuple: كائن شبيه بالكلاس بخواص مسماة
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)
يوفّر طريقة منظمة للتعامل مع البيانات مثل الكلاسات، لكن أخف وأسرع.
4. deque: قائمة مضاعفة النهاية (Double-ended queue)
from collections import deque
q = deque()
q.append(1)
q.appendleft(0)
print(q)
q.pop()
q.popleft()
أسرع من القائمة العادية عند الإضافة أو الحذف من الجانبين.
5. OrderedDict (في الإصدارات القديمة من بايثون <3.7):
يحافظ على ترتيب الإدخال. في الإصدارات الحديثة هذا السلوك مدمج بالفعل في dict.
from collections import OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
print(od)
مكتبة collections مثالية لتحسين الأداء، كتابة كود أكثر وضوحًا، وتقليل التعقيد عند العمل مع البيانات الهيكلية أو الإحصائية أو عند تطوير خوارزميات تعتمد على التجميع أو العد أو ترتيب العناصر.
في الختام، توفر بايثون مجموعة غنية من المكتبات المدمجة التي تغنيك في كثير من الأحيان عن تثبيت أي مكتبات خارجية، وتمنحك أدوات قوية وجاهزة لمعالجة النصوص، التعامل مع البيانات، إدارة النظام، تنفيذ العمليات الرياضية، توليد الأرقام العشوائية، التعامل مع ملفات JSON، وغير ذلك الكثير. إتقان هذه المكتبات لا يعني فقط كتابة كود أقصر، بل كود أكثر كفاءة وسرعة وأقل اعتمادًا على مصادر خارجية. لذلك، من المهم لكل مطور بايثون أن يعرف هذه الأدوات ويتقن استخدامها ضمن صندوق أدواته اليومي.